@nocobase/flow-engine 2.2.0-beta.3 → 2.2.0-beta.5

package/lib/flowSettings.d.ts

@@ -9,7 +9,7 @@
 import React from 'react';
 import { FlowEngine } from '.';
 import type { FlowModel } from './models';
-import { StepSettingsDialogProps, ToolbarItemConfig } from './types';
+import { DynamicFlowSource, DynamicFlowSourceProvider, StepSettingsDialogProps, ToolbarItemConfig } from './types';
 /**
  * 打开流程设置的参数接口
  */
@@ -93,6 +93,7 @@ export declare class FlowSettings {
     enabled: boolean;
     private engine;
     toolbarItems: ToolbarItemConfig[];
+    private dynamicFlowSourceProviders;
     constructor(engine: FlowEngine);
     on(event: 'beforeOpen', callback: (...args: any[]) => void): void;
     off(event: 'beforeOpen', callback: (...args: any[]) => void): void;
@@ -206,6 +207,9 @@ export declare class FlowSettings {
      * @returns {ToolbarItemConfig[]} 所有项目配置
      */
     getToolbarItems(): ToolbarItemConfig[];
+    registerDynamicFlowSourceProvider(provider: DynamicFlowSourceProvider): () => void;
+    hasDynamicFlowSourceProvider(model: FlowModel): boolean;
+    getDynamicFlowSources(model: FlowModel): Promise<DynamicFlowSource[]>;
     /**
      * 清空所有工具栏项目
      * @example

package/lib/flowSettings.js

@@ -78,6 +78,7 @@ const _FlowSettings = class _FlowSettings {
     __privateAdd(this, _forceEnabled, false);
     // 强制启用状态，主要用于设计模式下的强制启用
     __publicField(this, "toolbarItems", []);
+    __publicField(this, "dynamicFlowSourceProviders", []);
     __privateAdd(this, _emitter, new import_emitter.Emitter());
     this.engine = engine;
     this.enabled = false;
@@ -369,6 +370,75 @@ const _FlowSettings = class _FlowSettings {
   getToolbarItems() {
     return [...this.toolbarItems];
   }
+  registerDynamicFlowSourceProvider(provider) {
+    const existingIndex = this.dynamicFlowSourceProviders.findIndex((item) => item.key === provider.key);
+    if (existingIndex !== -1) {
+      console.warn(
+        `FlowSettings: Dynamic flow source provider with key '${provider.key}' already exists and will be replaced.`
+      );
+      this.dynamicFlowSourceProviders[existingIndex] = provider;
+    } else {
+      this.dynamicFlowSourceProviders.push(provider);
+    }
+    this.dynamicFlowSourceProviders.sort((a, b) => (a.sort || 0) - (b.sort || 0));
+    return () => {
+      const index = this.dynamicFlowSourceProviders.indexOf(provider);
+      if (index !== -1) {
+        this.dynamicFlowSourceProviders.splice(index, 1);
+      }
+    };
+  }
+  hasDynamicFlowSourceProvider(model) {
+    return this.dynamicFlowSourceProviders.some((provider) => {
+      try {
+        return provider.visible ? provider.visible(model) : true;
+      } catch (error) {
+        console.warn(`FlowSettings: Dynamic flow source provider '${provider.key}' visibility check failed.`, error);
+        return false;
+      }
+    });
+  }
+  async getDynamicFlowSources(model) {
+    const t = (0, import_utils.getT)(model);
+    const selfSource = {
+      key: "self",
+      label: t("Current block"),
+      model,
+      sort: -1e3
+    };
+    const sources = [];
+    const seenKeys = /* @__PURE__ */ new Set(["self"]);
+    const seenModelUids = /* @__PURE__ */ new Set([model.uid]);
+    for (const provider of this.dynamicFlowSourceProviders) {
+      try {
+        if (provider.visible && !provider.visible(model)) {
+          continue;
+        }
+        const providerSources = await provider.getSources(model);
+        for (const source of providerSources || []) {
+          if (!(source == null ? void 0 : source.key) || !source.model) {
+            continue;
+          }
+          const key = String(source.key);
+          const uid = source.model.uid;
+          if (seenKeys.has(key) || seenModelUids.has(uid)) {
+            continue;
+          }
+          seenKeys.add(key);
+          seenModelUids.add(uid);
+          sources.push({
+            ...source,
+            key,
+            label: source.label || key,
+            sort: source.sort || 0
+          });
+        }
+      } catch (error) {
+        console.warn(`FlowSettings: Dynamic flow source provider '${provider.key}' failed.`, error);
+      }
+    }
+    return [selfSource, ...sources.sort((a, b) => (a.sort || 0) - (b.sort || 0))];
+  }
   /**
    * 清空所有工具栏项目
    * @example

package/lib/types.d.ts

@@ -500,6 +500,18 @@ export interface ToolbarItemConfig {
     /** 排序权重，数字越小越靠右（先添加的在右边） */
     sort?: number;
 }
+export interface DynamicFlowSource {
+    key: string;
+    label: React.ReactNode;
+    model: FlowModel;
+    sort?: number;
+}
+export interface DynamicFlowSourceProvider {
+    key: string;
+    sort?: number;
+    visible?: (model: FlowModel) => boolean;
+    getSources: (model: FlowModel) => DynamicFlowSource[] | Promise<DynamicFlowSource[]>;
+}
 export interface ApplyFlowCacheEntry {
     status: 'pending' | 'resolved' | 'rejected';
     promise: Promise<any>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/flow-engine",
-  "version": "2.2.0-beta.3",
+  "version": "2.2.0-beta.5",
   "private": false,
   "description": "A standalone flow engine for NocoBase, managing workflows, models, and actions.",
   "main": "lib/index.js",
@@ -8,8 +8,8 @@
   "dependencies": {
     "@formily/antd-v5": "1.x",
     "@formily/reactive": "2.x",
-    "@nocobase/sdk": "2.2.0-beta.3",
-    "@nocobase/shared": "2.2.0-beta.3",
+    "@nocobase/sdk": "2.2.0-beta.5",
+    "@nocobase/shared": "2.2.0-beta.5",
     "ahooks": "^3.7.2",
     "axios": "^1.7.0",
     "dayjs": "^1.11.9",
@@ -37,5 +37,5 @@
   ],
   "author": "NocoBase Team",
   "license": "Apache-2.0",
-  "gitHead": "7b16bb2cfd427c110c6671252138cd85155723c5"
+  "gitHead": "81eab2cfa9d3d989e99ba0c914807b38db55f023"
 }

package/src/__tests__/flowSettings.test.ts

@@ -557,6 +557,78 @@ describe('FlowSettings', () => {
     });
   });
 
+  describe('Dynamic Flow Source Providers', () => {
+    test('should return current model as the default dynamic flow source', async () => {
+      const model = new FlowModel({ uid: 'source-model', flowEngine: engine });
+
+      const sources = await flowSettings.getDynamicFlowSources(model);
+
+      expect(sources).toHaveLength(1);
+      expect(sources[0].key).toBe('self');
+      expect(sources[0].label).toBe('Current block');
+      expect(sources[0].model).toBe(model);
+    });
+
+    test('should register, resolve, and dispose dynamic flow source providers', async () => {
+      const model = new FlowModel({ uid: 'source-model', flowEngine: engine });
+      const target = new FlowModel({ uid: 'target-model', flowEngine: engine });
+
+      const dispose = flowSettings.registerDynamicFlowSourceProvider({
+        key: 'test-provider',
+        visible: (m) => m.uid === model.uid,
+        getSources: () => [{ key: 'target', label: 'Target model', model: target, sort: 10 }],
+      });
+
+      expect(flowSettings.hasDynamicFlowSourceProvider(model)).toBe(true);
+      expect(flowSettings.hasDynamicFlowSourceProvider(target)).toBe(false);
+
+      const sources = await flowSettings.getDynamicFlowSources(model);
+      expect(sources.map((source) => source.key)).toEqual(['self', 'target']);
+
+      dispose();
+
+      expect(flowSettings.hasDynamicFlowSourceProvider(model)).toBe(false);
+      await expect(flowSettings.getDynamicFlowSources(model)).resolves.toHaveLength(1);
+    });
+
+    test('should skip duplicate dynamic flow source keys and model uids', async () => {
+      const model = new FlowModel({ uid: 'source-model', flowEngine: engine });
+      const target = new FlowModel({ uid: 'target-model', flowEngine: engine });
+
+      flowSettings.registerDynamicFlowSourceProvider({
+        key: 'test-provider',
+        getSources: () => [
+          { key: 'target', label: 'Target model', model: target },
+          { key: 'target', label: 'Duplicate key', model: new FlowModel({ uid: 'other-model', flowEngine: engine }) },
+          { key: 'duplicate-uid', label: 'Duplicate uid', model: target },
+        ],
+      });
+
+      const sources = await flowSettings.getDynamicFlowSources(model);
+
+      expect(sources.map((source) => source.key)).toEqual(['self', 'target']);
+    });
+
+    test('should ignore failing dynamic flow source providers', async () => {
+      const model = new FlowModel({ uid: 'source-model', flowEngine: engine });
+
+      flowSettings.registerDynamicFlowSourceProvider({
+        key: 'failing-provider',
+        getSources: () => {
+          throw new Error('provider failed');
+        },
+      });
+
+      const sources = await flowSettings.getDynamicFlowSources(model);
+
+      expect(sources.map((source) => source.key)).toEqual(['self']);
+      expect(consoleSpy.warn).toHaveBeenCalledWith(
+        "FlowSettings: Dynamic flow source provider 'failing-provider' failed.",
+        expect.any(Error),
+      );
+    });
+  });
+
   describe('Step Settings Dialog', () => {
     test('should call openStepSettingsDialog with correct parameters', async () => {
       const { openStepSettingsDialog } = await import('../components/settings/wrappers/contextual/StepSettingsDialog');

package/src/flowSettings.ts

@@ -20,7 +20,13 @@ import { FlowRuntimeContext } from './flowContext';
 import { FlowEngine, untracked } from '.';
 import { FlowSettingsContextProvider, useFlowSettingsContext } from './hooks/useFlowSettingsContext';
 import type { FlowModel } from './models';
-import { ParamObject, StepSettingsDialogProps, ToolbarItemConfig } from './types';
+import {
+  DynamicFlowSource,
+  DynamicFlowSourceProvider,
+  ParamObject,
+  StepSettingsDialogProps,
+  ToolbarItemConfig,
+} from './types';
 import {
   compileUiSchema,
   FlowCancelSaveException,
@@ -128,6 +134,7 @@ export class FlowSettings {
   private engine: FlowEngine;
   #forceEnabled = false; // 强制启用状态，主要用于设计模式下的强制启用
   public toolbarItems: ToolbarItemConfig[] = [];
+  private dynamicFlowSourceProviders: DynamicFlowSourceProvider[] = [];
   #emitter: Emitter = new Emitter();
 
   constructor(engine: FlowEngine) {
@@ -463,6 +470,83 @@ export class FlowSettings {
     return [...this.toolbarItems];
   }
 
+  public registerDynamicFlowSourceProvider(provider: DynamicFlowSourceProvider): () => void {
+    const existingIndex = this.dynamicFlowSourceProviders.findIndex((item) => item.key === provider.key);
+    if (existingIndex !== -1) {
+      console.warn(
+        `FlowSettings: Dynamic flow source provider with key '${provider.key}' already exists and will be replaced.`,
+      );
+      this.dynamicFlowSourceProviders[existingIndex] = provider;
+    } else {
+      this.dynamicFlowSourceProviders.push(provider);
+    }
+
+    this.dynamicFlowSourceProviders.sort((a, b) => (a.sort || 0) - (b.sort || 0));
+
+    return () => {
+      const index = this.dynamicFlowSourceProviders.indexOf(provider);
+      if (index !== -1) {
+        this.dynamicFlowSourceProviders.splice(index, 1);
+      }
+    };
+  }
+
+  public hasDynamicFlowSourceProvider(model: FlowModel): boolean {
+    return this.dynamicFlowSourceProviders.some((provider) => {
+      try {
+        return provider.visible ? provider.visible(model) : true;
+      } catch (error) {
+        console.warn(`FlowSettings: Dynamic flow source provider '${provider.key}' visibility check failed.`, error);
+        return false;
+      }
+    });
+  }
+
+  public async getDynamicFlowSources(model: FlowModel): Promise<DynamicFlowSource[]> {
+    const t = getT(model);
+    const selfSource: DynamicFlowSource = {
+      key: 'self',
+      label: t('Current block'),
+      model,
+      sort: -1000,
+    };
+    const sources: DynamicFlowSource[] = [];
+    const seenKeys = new Set<string>(['self']);
+    const seenModelUids = new Set<string>([model.uid]);
+
+    for (const provider of this.dynamicFlowSourceProviders) {
+      try {
+        if (provider.visible && !provider.visible(model)) {
+          continue;
+        }
+
+        const providerSources = await provider.getSources(model);
+        for (const source of providerSources || []) {
+          if (!source?.key || !source.model) {
+            continue;
+          }
+          const key = String(source.key);
+          const uid = source.model.uid;
+          if (seenKeys.has(key) || seenModelUids.has(uid)) {
+            continue;
+          }
+          seenKeys.add(key);
+          seenModelUids.add(uid);
+          sources.push({
+            ...source,
+            key,
+            label: source.label || key,
+            sort: source.sort || 0,
+          });
+        }
+      } catch (error) {
+        console.warn(`FlowSettings: Dynamic flow source provider '${provider.key}' failed.`, error);
+      }
+    }
+
+    return [selfSource, ...sources.sort((a, b) => (a.sort || 0) - (b.sort || 0))];
+  }
+
   /**
    * 清空所有工具栏项目
    * @example

package/src/types.ts

@@ -612,6 +612,20 @@ export interface ToolbarItemConfig {
   sort?: number;
 }
 
+export interface DynamicFlowSource {
+  key: string;
+  label: React.ReactNode;
+  model: FlowModel;
+  sort?: number;
+}
+
+export interface DynamicFlowSourceProvider {
+  key: string;
+  sort?: number;
+  visible?: (model: FlowModel) => boolean;
+  getSources: (model: FlowModel) => DynamicFlowSource[] | Promise<DynamicFlowSource[]>;
+}
+
 export interface ApplyFlowCacheEntry {
   status: 'pending' | 'resolved' | 'rejected';
   promise: Promise<any>;