@nocobase/flow-engine 2.1.0-alpha.3 → 2.1.0-alpha.31

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,31 @@ 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;
+    getFieldInterface?: (name: 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 +53,38 @@ 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);
+  }
+
+  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 +101,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 +135,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 +344,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 +391,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 +408,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 +448,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 +467,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 +481,7 @@ export class CollectionManager {
       throw new Error(`Collection ${newOptions.name} not found`);
     }
     collection.setOptions(newOptions, options);
+    this.resetCaches();
   }
 
   upsertCollection(options: CollectionOptions) {
@@ -239,6 +501,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 +583,7 @@ export class CollectionManager {
 
   clearCollections() {
     this.collections.clear();
+    this.resetCaches();
   }
 
   getAssociation(associationName: string): CollectionField | undefined {
@@ -501,6 +770,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 +806,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>();
@@ -856,7 +1135,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 +1172,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

@@ -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) {
       // 进入错误钩子并记录

package/src/executor/__tests__/flowExecutor.test.ts

@@ -232,6 +232,37 @@ describe('FlowExecutor', () => {
     expect(calls.sort()).toEqual(['a', 'b']);
   });
 
+  it('dispatchEvent sequential exposes abortedByExitAll metadata on result array', async () => {
+    const flows = {
+      stopClose: {
+        on: { eventName: 'close' },
+        steps: {
+          only: {
+            handler: vi.fn().mockImplementation((ctx) => {
+              ctx.exit();
+            }),
+          },
+        },
+      },
+      afterClose: {
+        on: { eventName: 'close', phase: 'afterAllFlows' },
+        steps: {
+          only: {
+            handler: vi.fn(),
+          },
+        },
+      },
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+
+    const model = createModelWithFlows('m-close-meta', flows);
+
+    const result = await engine.executor.dispatchEvent(model, 'close', {}, { sequential: true });
+
+    expect(Array.isArray(result)).toBe(true);
+    expect((result as any).__abortedByExitAll).toBe(true);
+    expect(flows.afterClose.steps.only.handler).not.toHaveBeenCalled();
+  });
+
   it('dispatchEvent sequential respects sort order and stops on errors', async () => {
     const calls: string[] = [];
     const mkFlow = (key: string, sort: number, opts?: { throw?: boolean }) => ({
@@ -288,6 +319,32 @@ describe('FlowExecutor', () => {
     expect(handler).toHaveBeenCalledTimes(2); // 每个 flow 各 1 次，共 2 次
   });
 
+  it("dispatchEvent('beforeRender') keeps aborted flag on end event when cache hits", async () => {
+    const handler = vi.fn().mockImplementation((ctx) => {
+      ctx.exitAll();
+    });
+    const flows = {
+      abortFlow: { steps: { s: { handler } } },
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+    const model = createModelWithFlows('m-br-cache-aborted', flows);
+
+    const endEvents: any[] = [];
+    const onEnd = (payload: any) => {
+      endEvents.push(payload);
+    };
+    engine.emitter.on('model:event:beforeRender:end', onEnd);
+
+    await engine.executor.dispatchEvent(model, 'beforeRender', undefined, { sequential: true, useCache: true });
+    await engine.executor.dispatchEvent(model, 'beforeRender', undefined, { sequential: true, useCache: true });
+
+    engine.emitter.off('model:event:beforeRender:end', onEnd);
+
+    expect(handler).toHaveBeenCalledTimes(1);
+    expect(endEvents).toHaveLength(2);
+    expect(endEvents[0]?.aborted).toBe(true);
+    expect(endEvents[1]?.aborted).toBe(true);
+  });
+
   it('dispatchEvent supports sequential execution order and exitAll break', async () => {
     const calls: string[] = [];
     const mkFlow = (key: string, sort: number, opts?: { exitAll?: boolean }) => ({