@nocobase/flow-engine 2.1.0-alpha.4 → 2.1.0-alpha.45

package/src/data-source/__tests__/index.test.ts

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import { DataSource, DataSourceManager } from '../index';
 import { FlowEngine } from '../../flowEngine';
 
@@ -79,4 +79,71 @@ describe('DataSource & Collection APIs', () => {
       ]),
     ).toThrow(/circular/);
   });
+
+  it('translates validation messages from data-source-main in component rules', async () => {
+    const { m, engine } = makeManager();
+    engine.context.i18n = {
+      t: (key: string, options?: Record<string, any>) => {
+        if (key === 'string.length' && options?.ns === 'data-source-main') {
+          return `${options.label} 长度必须为 ${options.limit} 个字符`;
+        }
+        return key;
+      },
+    } as any;
+
+    const ds = new DataSource({ key: 'main' });
+    m.addDataSource(ds);
+    ds.addCollection({
+      name: 'posts',
+      fields: [
+        {
+          name: 'title',
+          type: 'string',
+          interface: 'text',
+          title: '单行文本',
+          validation: {
+            type: 'string',
+            rules: [{ name: 'length', args: { limit: 18 } }],
+          },
+        },
+      ],
+    });
+
+    const rules = ds.getCollection('posts')!.getField('title')!.getComponentProps().rules;
+
+    await expect(rules[0].validator({}, '123')).rejects.toBe('单行文本 长度必须为 18 个字符');
+  });
+
+  it('ensureLoaded, reload and data source events work for main loader', async () => {
+    const { m, engine } = makeManager();
+    const loadedListener = vi.fn();
+    const failedListener = vi.fn();
+    engine.context.app = { eventBus: new EventTarget() } as any;
+    engine.context.app.eventBus.addEventListener('dataSource:loaded', loadedListener);
+    engine.context.app.eventBus.addEventListener('dataSource:loadFailed', failedListener);
+
+    const loader = vi
+      .fn()
+      .mockResolvedValueOnce({
+        collections: [{ name: 'posts', fields: [{ name: 'title', type: 'string', interface: 'input' }] }],
+      })
+      .mockResolvedValueOnce({
+        collections: [{ name: 'users', fields: [{ name: 'nickname', type: 'string', interface: 'input' }] }],
+      });
+
+    m.registerLoader('main', loader);
+
+    await m.ensureLoaded();
+    expect(loader).toHaveBeenCalledTimes(1);
+    expect(m.getDataSource('main')?.status).toBe('loaded');
+    expect(m.getCollection('main', 'posts')?.name).toBe('posts');
+    expect(loadedListener).toHaveBeenCalledTimes(1);
+
+    await m.reloadDataSource('main');
+    expect(loader).toHaveBeenCalledTimes(2);
+    expect(m.getCollection('main', 'posts')).toBeUndefined();
+    expect(m.getCollection('main', 'users')?.name).toBe('users');
+    expect(m.getDataSource('main')?.reload).toBeTypeOf('function');
+    expect(failedListener).not.toHaveBeenCalled();
+  });
 });

package/src/data-source/index.ts

@@ -8,7 +8,6 @@
  */
 
 import { observable } from '@formily/reactive';
-import { CascaderProps } from 'antd';
 import _ from 'lodash';
 import { FlowEngine } from '../flowEngine';
 import { jioToJoiSchema } from './jioToJoiSchema';
@@ -20,9 +19,37 @@ export interface DataSourceOptions extends Record<string, any> {
   [key: string]: any;
 }
 
+export type DataSourceRequester = (options: Record<string, any>) => Promise<any>;
+
+export interface DataSourceLoadResult {
+  collections?: CollectionOptions[];
+  dataSources?: Array<DataSourceOptions & { collections?: CollectionOptions[] }>;
+}
+
+export type DataSourceLoader = (context: { key: string; manager: DataSourceManager }) => Promise<DataSourceLoadResult>;
+
 export class DataSourceManager {
   dataSources: Map<string, DataSource>;
   flowEngine: FlowEngine;
+  requester?: DataSourceRequester;
+  collectionFieldInterfaceManager?: {
+    addFieldInterfaces?: (fieldInterfaceClasses?: any[]) => void;
+    addFieldInterfaceGroups?: (groups: Record<string, { label: string; order?: number }>) => void;
+    addFieldInterfaceComponentOption?: (name: string, option: any) => void;
+    addFieldInterfaceOperator?: (name: string, operator: any) => void;
+    registerFieldFilterOperator?: (operator: any) => void;
+    registerFieldFilterOperatorGroup?: (name: string, operators?: any[]) => void;
+    addFieldFilterOperatorsToGroup?: (name: string, operators?: any[]) => void;
+    getFieldInterface?: (name: string) => any;
+    registerFieldInterfaceConfigure?: (options: unknown) => void;
+    getFieldInterfaceConfigure?: (name: string, collectionInfo?: unknown) => unknown;
+    getFieldInterfaceConfigureProperties?: (name: string, collectionInfo?: any) => Record<string, any>;
+  };
+  loaders = new Map<string, DataSourceLoader>();
+  loadedKeys = new Set<string>();
+  loadingKeys = new Set<string>();
+  loadErrors = new Map<string, Error | null>();
+  loadingPromise: Promise<void> | null = null;
 
   constructor() {
     this.dataSources = observable.shallow<Map<string, DataSource>>(new Map());
@@ -32,6 +59,50 @@ export class DataSourceManager {
     this.flowEngine = flowEngine;
   }
 
+  setRequester(requester?: DataSourceRequester) {
+    this.requester = requester;
+  }
+
+  setCollectionFieldInterfaceManager(manager: DataSourceManager['collectionFieldInterfaceManager']) {
+    this.collectionFieldInterfaceManager = manager;
+  }
+
+  addFieldInterfaces(fieldInterfaceClasses: any[] = []) {
+    this.collectionFieldInterfaceManager?.addFieldInterfaces?.(fieldInterfaceClasses);
+  }
+
+  addFieldInterfaceGroups(groups: Record<string, { label: string; order?: number }>) {
+    this.collectionFieldInterfaceManager?.addFieldInterfaceGroups?.(groups);
+  }
+
+  addFieldInterfaceComponentOption(name: string, option: any) {
+    this.collectionFieldInterfaceManager?.addFieldInterfaceComponentOption?.(name, option);
+  }
+
+  addFieldInterfaceOperator(name: string, operator: any) {
+    this.collectionFieldInterfaceManager?.addFieldInterfaceOperator?.(name, operator);
+  }
+
+  registerFieldFilterOperator(operator: any) {
+    this.collectionFieldInterfaceManager?.registerFieldFilterOperator?.(operator);
+  }
+
+  registerFieldFilterOperatorGroup(name: string, operators: any[] = []) {
+    this.collectionFieldInterfaceManager?.registerFieldFilterOperatorGroup?.(name, operators);
+  }
+
+  addFieldFilterOperatorsToGroup(name: string, operators: any[] = []) {
+    this.collectionFieldInterfaceManager?.addFieldFilterOperatorsToGroup?.(name, operators);
+  }
+
+  registerLoader(key: string, loader: DataSourceLoader) {
+    this.loaders.set(key, loader);
+  }
+
+  removeLoader(key: string) {
+    this.loaders.delete(key);
+  }
+
   addDataSource(ds: DataSource | DataSourceOptions) {
     if (this.dataSources.has(ds.key)) {
       throw new Error(`DataSource with name ${ds.key} already exists`);
@@ -48,7 +119,7 @@ export class DataSourceManager {
 
   upsertDataSource(ds: DataSource | DataSourceOptions) {
     if (this.dataSources.has(ds.key)) {
-      this.dataSources.get(ds.key)?.setOptions(ds);
+      this.dataSources.get(ds.key)?.patchOptions(ds);
     } else {
       this.addDataSource(ds);
     }
@@ -82,6 +153,187 @@ export class DataSourceManager {
     if (!ds) return undefined;
     return ds.getCollectionField(otherKeys.join('.'));
   }
+
+  async ensureLoaded(options: { force?: boolean; keys?: string[] } = {}) {
+    const { force = false } = options;
+    const keys = this.resolveLoadKeys(options.keys);
+    const pendingKeys = force ? keys : keys.filter((key) => !this.loadedKeys.has(key));
+    if (!pendingKeys.length) {
+      return;
+    }
+    if (this.loadingPromise) {
+      return this.loadingPromise;
+    }
+
+    this.loadingPromise = (async () => {
+      try {
+        for (const key of pendingKeys) {
+          await this.loadKey(key, { initial: !this.loadedKeys.has(key), force });
+        }
+      } finally {
+        this.loadingPromise = null;
+      }
+    })();
+
+    return this.loadingPromise;
+  }
+
+  async reload(options: { keys?: string[] } = {}) {
+    const keys = this.resolveLoadKeys(options.keys);
+    if (!keys.length) {
+      return;
+    }
+    if (this.loadingPromise) {
+      return this.loadingPromise;
+    }
+
+    this.loadingPromise = (async () => {
+      try {
+        for (const key of keys) {
+          await this.loadKey(key, { initial: false, force: true });
+        }
+      } finally {
+        this.loadingPromise = null;
+      }
+    })();
+
+    return this.loadingPromise;
+  }
+
+  async reloadDataSource(key: string) {
+    if (this.loadingKeys.has(key) && this.loadingPromise) {
+      return this.loadingPromise;
+    }
+    if (!this.loaders.has(key) && this.loaders.has('*')) {
+      return this.reload({ keys: ['*'] });
+    }
+    return this.reload({ keys: [key] });
+  }
+
+  protected resolveLoadKeys(requestedKeys?: string[]) {
+    const normalizedKeys = requestedKeys?.length ? requestedKeys : ['main'];
+    const explicitKeys = normalizedKeys.filter((key) => this.loaders.has(key));
+    if (this.loaders.has('*')) {
+      return _.uniq(['*', ...explicitKeys]);
+    }
+    return explicitKeys.length ? explicitKeys : normalizedKeys;
+  }
+
+  protected getApp() {
+    return this.flowEngine?.context?.app as { eventBus?: EventTarget } | undefined;
+  }
+
+  protected dispatchDataSourceEvent(
+    type: 'dataSource:loaded' | 'dataSource:loadFailed',
+    detail: { dataSourceKey: string; initial: boolean; error?: Error },
+  ) {
+    this.getApp()?.eventBus?.dispatchEvent(new CustomEvent(type, { detail }));
+  }
+
+  protected setDataSourceState(
+    key: string,
+    options: Partial<Pick<DataSourceOptions, 'status' | 'errorMessage'>> & Record<string, any>,
+  ) {
+    const dataSource = this.getDataSource(key);
+    if (!dataSource) {
+      return;
+    }
+    dataSource.patchOptions(options);
+  }
+
+  protected applyDataSourceLoadResult(key: string, result: DataSourceLoadResult) {
+    if (key === '*') {
+      const dataSources = result?.dataSources || [];
+      dataSources.forEach((dataSourceOptions) => {
+        const { collections, ...dataSource } = dataSourceOptions;
+        this.upsertDataSource(dataSource);
+        if (collections) {
+          this.getDataSource(dataSource.key)?.setCollections(collections, { clearFields: true });
+        }
+      });
+      return;
+    }
+
+    const dataSource = this.getDataSource(key);
+    if (!dataSource) {
+      return;
+    }
+    dataSource.setCollections(result?.collections || [], { clearFields: true });
+  }
+
+  protected async loadKey(key: string, options: { initial: boolean; force: boolean }) {
+    const loader = this.loaders.get(key);
+    if (!loader) {
+      return;
+    }
+
+    if (!this.getDataSource(key) && key !== '*') {
+      this.addDataSource({ key });
+    }
+
+    const { initial } = options;
+    this.loadingKeys.add(key);
+    if (key !== '*') {
+      this.setDataSourceState(key, {
+        status: initial ? 'loading' : 'reloading',
+        errorMessage: undefined,
+      });
+    }
+    this.loadErrors.set(key, null);
+
+    try {
+      const result = (await loader({ key, manager: this })) || {};
+      this.applyDataSourceLoadResult(key, result);
+      this.loadedKeys.add(key);
+      if (key !== '*') {
+        this.setDataSourceState(key, {
+          status: 'loaded',
+          errorMessage: undefined,
+        });
+      }
+      this.dispatchDataSourceEvent('dataSource:loaded', { dataSourceKey: key, initial });
+    } catch (error) {
+      const normalizedError = error instanceof Error ? error : new Error(String(error));
+      this.loadErrors.set(key, normalizedError);
+      if (key !== '*') {
+        this.setDataSourceState(key, {
+          status: initial ? 'loading-failed' : 'reloading-failed',
+          errorMessage: normalizedError.message,
+        });
+      }
+      this.dispatchDataSourceEvent('dataSource:loadFailed', {
+        dataSourceKey: key,
+        initial,
+        error: normalizedError,
+      });
+      throw normalizedError;
+    } finally {
+      this.loadingKeys.delete(key);
+    }
+  }
+}
+
+export type CollectionFieldInterfaceDataSourceManager = Pick<DataSourceManager, 'collectionFieldInterfaceManager'>;
+
+export function getCollectionFieldInterface(
+  interfaceName: string | undefined,
+  ...dataSourceManagers: Array<CollectionFieldInterfaceDataSourceManager | null | undefined>
+) {
+  if (!interfaceName) {
+    return undefined;
+  }
+
+  // TODO: Once legacy client is removed and all runtimes share the client-v2 flow-engine
+  // DataSourceManager, callers should only pass the flow-engine context DataSourceManager.
+  for (const dataSourceManager of dataSourceManagers) {
+    const collectionFieldInterfaceManager = dataSourceManager?.collectionFieldInterfaceManager;
+    const getFieldInterface = collectionFieldInterfaceManager?.getFieldInterface;
+    if (typeof getFieldInterface === 'function') {
+      return getFieldInterface.call(collectionFieldInterfaceManager, interfaceName);
+    }
+  }
+
+  return undefined;
 }
 
 export class DataSource {
@@ -110,6 +362,14 @@ export class DataSource {
     return this.options.key;
   }
 
+  get status() {
+    return this.options.status;
+  }
+
+  get errorMessage() {
+    return this.options.errorMessage;
+  }
+
   setDataSourceManager(dataSourceManager: DataSourceManager) {
     this.dataSourceManager = dataSourceManager;
   }
@@ -149,6 +409,10 @@ export class DataSource {
     return this.collectionManager.upsertCollections(collections, options);
   }
 
+  setCollections(collections: CollectionOptions[], options: { clearFields?: boolean } = {}) {
+    return this.collectionManager.setCollections(collections, options);
+  }
+
   removeCollection(name: string) {
     return this.collectionManager.removeCollection(name);
   }
@@ -162,6 +426,14 @@ export class DataSource {
     Object.assign(this.options, newOptions);
   }
 
+  patchOptions(newOptions: any = {}) {
+    Object.assign(this.options, newOptions);
+  }
+
+  reload() {
+    return this.dataSourceManager.reloadDataSource(this.key);
+  }
+
   getCollectionField(fieldPath: string) {
     const [collectionName, ...otherKeys] = fieldPath.split('.');
     const fieldName = otherKeys.join('.');
@@ -194,6 +466,11 @@ export class CollectionManager {
     this.collections = observable.shallow<Map<string, Collection>>(new Map());
   }
 
+  protected resetCaches() {
+    this.childrenCollectionsName = {};
+    this.allCollectionsInheritChain = undefined;
+  }
+
   get flowEngine() {
     return this.dataSource.flowEngine;
   }
@@ -208,10 +485,12 @@ export class CollectionManager {
     col.setDataSource(this.dataSource);
     col.initInherits();
     this.collections.set(col.name, col);
+    this.resetCaches();
   }
 
   removeCollection(name: string) {
     this.collections.delete(name);
+    this.resetCaches();
   }
 
   updateCollection(newOptions: CollectionOptions, options: { clearFields?: boolean } = {}) {
@@ -220,6 +499,7 @@ export class CollectionManager {
       throw new Error(`Collection ${newOptions.name} not found`);
     }
     collection.setOptions(newOptions, options);
+    this.resetCaches();
   }
 
   upsertCollection(options: CollectionOptions) {
@@ -239,6 +519,12 @@ export class CollectionManager {
         this.addCollection(collection);
       }
     }
+    this.resetCaches();
+  }
+
+  setCollections(collections: CollectionOptions[], options: { clearFields?: boolean } = {}) {
+    this.clearCollections();
+    this.upsertCollections(collections, options);
   }
 
   sortCollectionsByInherits(collections: CollectionOptions[]): CollectionOptions[] {
@@ -315,6 +601,7 @@ export class CollectionManager {
 
   clearCollections() {
     this.collections.clear();
+    this.resetCaches();
   }
 
   getAssociation(associationName: string): CollectionField | undefined {
@@ -501,6 +788,12 @@ export class Collection {
 
   get titleCollectionField() {
     const titleFieldName = this.options.titleField || this.filterTargetKey;
+    if (Array.isArray(titleFieldName)) {
+      if (titleFieldName.length !== 1) {
+        return undefined;
+      }
+      return this.getField(titleFieldName[0]);
+    }
     const titleCollectionField = this.getField(titleFieldName);
     return titleCollectionField;
   }
@@ -531,6 +824,10 @@ export class Collection {
     this.upsertFields(this.options.fields || []);
   }
 
+  setOption(key: string, value: any) {
+    this.options[key] = value;
+  }
+
   getFields(): CollectionField[] {
     // 合并自身 fields 和所有 inherits 的 fields，后者优先被覆盖
     const fieldMap = new Map<string, CollectionField>();
@@ -835,7 +1132,7 @@ export class CollectionField {
       {
         ..._.omit(this.options.uiSchema?.['x-component-props'] || {}, 'fieldNames'),
         options: this.enum.length ? this.enum : undefined,
-        mode: this.type === 'array' ? 'multiple' : undefined,
+        mode: this.interface === 'multipleSelect' ? 'multiple' : undefined,
         multiple: target ? ['belongsToMany', 'hasMany', 'belongsToArray'].includes(type) : undefined,
         maxCount: target && !['belongsToMany', 'hasMany', 'belongsToArray'].includes(type) ? 1 : undefined,
         target: target,
@@ -856,7 +1153,21 @@ export class CollectionField {
           });
 
           if (error) {
-            const message = error.details.map((d: any) => d.message.replace(/"value"/g, `"${label}"`)).join(', ');
+            const message = error.details
+              .map((d: any) => {
+                const translated = this.flowEngine.translate(d.type, {
+                  ...d.context,
+                  ns: 'data-source-main',
+                  label,
+                });
+
+                if (translated && translated !== d.type) {
+                  return translated;
+                }
+
+                return d.message.replace(/"value"/g, `"${label}"`);
+              })
+              .join(', ');
             return Promise.reject(message);
           }
 
@@ -879,8 +1190,13 @@ export class CollectionField {
   }
 
   getInterfaceOptions() {
-    const app = this.flowEngine.context.app;
-    return app.dataSourceManager.collectionFieldInterfaceManager.getFieldInterface(this.interface);
+    const ctx = this.flowEngine.context;
+    return getCollectionFieldInterface(
+      this.interface,
+      this.collection?.dataSource?.dataSourceManager,
+      ctx.dataSourceManager,
+      ctx.app?.dataSourceManager,
+    );
   }
 
   getFilterOperators() {

package/src/executor/FlowExecutor.ts

@@ -158,7 +158,7 @@ export class FlowExecutor {
         const stepDefaultParams = await resolveDefaultParams(step.defaultParams, runtimeCtx);
         combinedParams = { ...stepDefaultParams };
       } else {
-        flowContext.logger.error(
+        flowContext.logger.warn(
           `BaseModel.applyFlow: Step '${stepKey}' in flow '${flowKey}' has neither 'use' nor 'handler'. Skipping.`,
         );
         continue;
@@ -224,10 +224,12 @@ export class FlowExecutor {
           await this.emitModelEventIf(eventName, `flow:${flowKey}:step:${stepKey}:end`, {
             ...flowEventBasePayload,
             stepKey,
+            aborted: true,
           });
           await this.emitModelEventIf(eventName, `flow:${flowKey}:end`, {
             ...flowEventBasePayload,
             result: error,
+            aborted: true,
           });
           return Promise.resolve(error);
         }
@@ -316,9 +318,9 @@ export class FlowExecutor {
 
     // 记录本次 dispatchEvent 内注册的调度任务，用于在结束/错误后兜底清理未触发的任务
     const scheduledCancels: ScheduledCancel[] = [];
-
-    // 组装执行函数（返回值用于缓存；beforeRender 返回 results:any[]，其它返回 true）
-    const execute = async () => {
+    // 组装执行函数（返回值用于缓存，包含事件结果与是否被 exitAll 中止）
+    const execute = async (): Promise<{ result: any[]; abortedByExitAll: boolean }> => {
+      let abortedByExitAll = false;
       if (sequential) {
         // 顺序执行：动态流（实例级）优先，其次静态流；各自组内再按 sort 升序，最后保持原始顺序稳定
         const flowsWithIndex = flowsToRun.map((f, i) => ({ f, i }));
@@ -351,7 +353,7 @@ export class FlowExecutor {
             .map((f) => [f.key, f] as const),
         );
         const scheduled = new Set<string>();
-        const scheduleGroups = new Map<string, Array<{ flow: any; order: number }>>();
+        const scheduleGroups = new Map<string, Array<{ flow: any; order: number; shouldSkipOnAborted: boolean }>>();
         ordered.forEach((flow, indexInOrdered) => {
           const on = flow.on;
           const onObj = typeof on === 'object' ? (on as any) : undefined;
@@ -402,9 +404,11 @@ export class FlowExecutor {
           }
 
           if (!whenKey) return;
+          const shouldSkipOnAborted =
+            whenKey === `event:${eventName}:end` || phase === 'afterFlow' || phase === 'afterStep';
           scheduled.add(flow.key);
           const list = scheduleGroups.get(whenKey) || [];
-          list.push({ flow, order: indexInOrdered });
+          list.push({ flow, order: indexInOrdered, shouldSkipOnAborted });
           scheduleGroups.set(whenKey, list);
         });
 
@@ -417,6 +421,14 @@ export class FlowExecutor {
             return a.order - b.order;
           });
           for (const it of sorted) {
+            const when = it.shouldSkipOnAborted
+              ? Object.assign(
+                  (event: { type: string; aborted?: boolean }) => event.type === whenKey && event.aborted !== true,
+                  {
+                    __eventType: whenKey,
+                  },
+                )
+              : (whenKey as any);
             const cancel = model.scheduleModelOperation(
               model.uid,
               async (m) => {
@@ -426,7 +438,7 @@ export class FlowExecutor {
                 }
                 results.push(res);
               },
-              { when: whenKey as any },
+              { when },
             );
             scheduledCancels.push(cancel);
           }
@@ -441,12 +453,14 @@ export class FlowExecutor {
             const result = await this.runFlow(model, flow.key, inputArgs, runId, eventName);
             if (result instanceof FlowExitAllException) {
               logger.debug(`[FlowEngine.dispatchEvent] ${result.message}`);
+              abortedByExitAll = true;
               break; // 终止后续
             }
             results.push(result);
           } catch (error) {
             if (error instanceof FlowExitAllException) {
               logger.debug(`[FlowEngine.dispatchEvent] ${error.message}`);
+              abortedByExitAll = true;
               break; // 终止后续
             }
             logger.error(
@@ -456,7 +470,7 @@ export class FlowExecutor {
             throw error;
           }
         }
-        return results;
+        return { result: results, abortedByExitAll };
       }
 
       // 并行
@@ -475,7 +489,11 @@ export class FlowExecutor {
           }
         }),
       );
-      return results.filter((x) => x !== undefined);
+      const filteredResults = results.filter((x) => x !== undefined);
+      if (filteredResults.some((x) => x instanceof FlowExitAllException)) {
+        abortedByExitAll = true;
+      }
+      return { result: filteredResults, abortedByExitAll };
     };
 
     // 缓存键：按事件+scope 统一管理（beforeRender 也使用事件名 beforeRender）
@@ -489,7 +507,7 @@ export class FlowExecutor {
       : null;
 
     try {
-      const result = await this.withApplyFlowCache(cacheKey, execute);
+      const { result, abortedByExitAll } = await this.withApplyFlowCache(cacheKey, execute);
       // 事件结束钩子
       try {
         await model.onDispatchEventEnd?.(eventName, options, inputArgs, result);
@@ -499,7 +517,14 @@ export class FlowExecutor {
       await this.emitModelEventIf(eventName, 'end', {
         ...eventBasePayload,
         result,
+        ...(abortedByExitAll ? { aborted: true } : {}),
       });
+      if (result && typeof result === 'object') {
+        Object.defineProperty(result, '__abortedByExitAll', {
+          value: abortedByExitAll,
+          configurable: true,
+        });
+      }
       return result;
     } catch (error) {
       // 进入错误钩子并记录