@nocobase/flow-engine 2.1.0-alpha.1 → 2.1.0-alpha.2

package/lib/data-source/index.js

@@ -118,7 +118,7 @@ const _DataSource = class _DataSource {
     return this.dataSourceManager.flowEngine;
   }
   get displayName() {
-    return this.options.displayName ? this.flowEngine.translate(this.options.displayName) : this.key;
+    return this.flowEngine.translate(this.options.displayName, { ns: "lm-collections" }) || this.key;
   }
   get key() {
     return this.options.key;
@@ -188,6 +188,8 @@ const _CollectionManager = class _CollectionManager {
     this.collections = import_reactive.observable.shallow(/* @__PURE__ */ new Map());
   }
   collections;
+  allCollectionsInheritChain;
+  childrenCollectionsName = {};
   get flowEngine() {
     return this.dataSource.flowEngine;
   }
@@ -317,56 +319,75 @@ const _CollectionManager = class _CollectionManager {
     }, "getChildrens");
     return getChildrens(name);
   }
-  getCollectionFieldsOptions(collectionName, type, interfaces, opts) {
-    var _a;
-    const {
-      association = false,
-      cached = {},
-      collectionNames = [collectionName],
-      maxDepth = 1,
-      allowAllTypes = false,
-      exceptInterfaces = [],
-      prefixFieldValue = "",
-      usePrefix = false,
-      dataSource: customDataSourceNameValue
-    } = opts || {};
-    if (collectionNames.length - 1 > maxDepth) {
-      return;
-    }
-    if (cached[collectionName]) {
-      return import_lodash.default.cloneDeep(cached[collectionName]);
+  getChildrenCollectionsName(name, isSupportView = false) {
+    const cacheKey = isSupportView ? "supportView" : "notSupportView";
+    if (this.childrenCollectionsName[cacheKey]) {
+      return this.childrenCollectionsName[cacheKey].slice();
     }
-    const collection = this.getCollection(collectionName);
-    if (!collection) {
-      throw new Error(`Collection ${collectionName} not found`);
-    }
-    const fields = collection.getFields();
-    const options = (_a = fields == null ? void 0 : fields.filter(
-      (field) => field.interface && !exceptInterfaces.includes(field.interface) && (allowAllTypes || type && type.includes(field.type) || interfaces && interfaces.includes(field.interface) || (association && field.target && field.target !== collectionName && Array.isArray(association) ? association.includes(field.interface) : false))
-    )) == null ? void 0 : _a.map((field) => {
-      var _a2, _b;
-      const result = {
-        value: usePrefix && prefixFieldValue ? `${prefixFieldValue}.${field.name}` : field.name,
-        label: ((_a2 = field == null ? void 0 : field.uiSchema) == null ? void 0 : _a2.title) || field.name,
-        ...field
-      };
-      if (association && field.target) {
-        result.children = collectionNames.includes(field.target) ? [] : this.getCollectionFieldsOptions(field.target, type, interfaces, {
-          ...opts,
-          cached,
-          dataSource: customDataSourceNameValue,
-          collectionNames: [...collectionNames, field.target],
-          prefixFieldValue: usePrefix ? prefixFieldValue ? `${prefixFieldValue}.${field.name}` : field.name : "",
-          usePrefix
+    const children = [];
+    const collections = [...this.getCollections()];
+    const getChildrenCollectionsInner = /* @__PURE__ */ __name((collectionName) => {
+      const inheritCollections = collections.filter((v) => {
+        var _a;
+        return (_a = [...v.inherits]) == null ? void 0 : _a.includes(collectionName);
+      });
+      inheritCollections.forEach((v) => {
+        const collectionKey = v.name;
+        children.push(collectionKey);
+        return getChildrenCollectionsInner(collectionKey);
+      });
+      if (isSupportView) {
+        const sourceCollections = collections.filter((v) => {
+          var _a;
+          return ((_a = [...v.sources]) == null ? void 0 : _a.length) === 1 && (v == null ? void 0 : v.sources[0]) === collectionName;
+        });
+        sourceCollections.forEach((v) => {
+          const collectionKey = v.name;
+          children.push(v.name);
+          return getChildrenCollectionsInner(collectionKey);
         });
-        if (!((_b = result.children) == null ? void 0 : _b.length)) {
-          return null;
+      }
+      return import_lodash.default.uniq(children);
+    }, "getChildrenCollectionsInner");
+    this.childrenCollectionsName[cacheKey] = getChildrenCollectionsInner(name);
+    return this.childrenCollectionsName[cacheKey];
+  }
+  getAllCollectionsInheritChain(name) {
+    if (this.allCollectionsInheritChain) {
+      return this.allCollectionsInheritChain.slice();
+    }
+    const collectionsInheritChain = [name];
+    const getInheritChain = /* @__PURE__ */ __name((name2) => {
+      const collection = this.getCollection(name2);
+      if (collection) {
+        const { inherits } = collection;
+        const children = this.getChildrenCollectionsName(name2);
+        if (inherits) {
+          for (let index = 0; index < inherits.length; index++) {
+            const collectionKey = inherits[index];
+            if (collectionsInheritChain.includes(collectionKey)) {
+              continue;
+            }
+            collectionsInheritChain.push(collectionKey);
+            getInheritChain(collectionKey);
+          }
+        }
+        if (children) {
+          for (let index = 0; index < children.length; index++) {
+            const collection2 = this.getCollection(children[index]);
+            const collectionKey = collection2.name;
+            if (collectionsInheritChain.includes(collectionKey)) {
+              continue;
+            }
+            collectionsInheritChain.push(collectionKey);
+            getInheritChain(collectionKey);
+          }
         }
       }
-      return result;
-    }).filter(Boolean);
-    cached[collectionName] = options;
-    return options;
+      return collectionsInheritChain;
+    }, "getInheritChain");
+    this.allCollectionsInheritChain = getInheritChain(name);
+    return this.allCollectionsInheritChain || [];
   }
 };
 __name(_CollectionManager, "CollectionManager");
@@ -400,6 +421,9 @@ const _Collection = class _Collection {
     if (typeof this.filterTargetKey === "string") {
       return record[this.filterTargetKey];
     }
+    if (Array.isArray(this.filterTargetKey) && this.filterTargetKey.length === 1) {
+      return record[this.filterTargetKey[0]];
+    }
     return import_lodash.default.pick(record, this.filterTargetKey);
   }
   get titleableFields() {
@@ -433,7 +457,7 @@ const _Collection = class _Collection {
     return this.options.storage || "local";
   }
   get title() {
-    return this.options.title ? this.flowEngine.translate(this.options.title) : this.name;
+    return this.flowEngine.translate(this.options.title, { ns: "lm-collections" }) || this.name;
   }
   get titleCollectionField() {
     const titleFieldName = this.options.titleField || this.filterTargetKey;
@@ -668,8 +692,8 @@ const _CollectionField = class _CollectionField {
   }
   get title() {
     var _a, _b, _c;
-    const titleValue = ((_b = (_a = this.options) == null ? void 0 : _a.uiSchema) == null ? void 0 : _b.title) || ((_c = this.options) == null ? void 0 : _c.title) || this.options.name;
-    return this.flowEngine.translate(titleValue);
+    const titleValue = ((_b = (_a = this.options) == null ? void 0 : _a.uiSchema) == null ? void 0 : _b.title) || ((_c = this.options) == null ? void 0 : _c.title);
+    return this.flowEngine.translate(titleValue, { ns: "lm-collections" }) || this.options.name;
   }
   set title(value) {
     this.options.title = value;
@@ -682,13 +706,22 @@ const _CollectionField = class _CollectionField {
         if (typeof v !== "object") {
           return v;
         }
+        if (v.value === null || v.value === void 0) {
+          return v;
+        }
         return {
           ...v,
+          label: v.label ? this.flowEngine.translate(v.label, { ns: "lm-collections" }) : v.label,
           value: Number(v.value)
         };
       });
     }
-    return options;
+    return options.map((v) => {
+      return {
+        ...v,
+        label: this.flowEngine.translate(v.label, { ns: "lm-collections" })
+      };
+    });
   }
   get defaultValue() {
     return this.options.defaultValue == null ? void 0 : this.options.defaultValue;

package/lib/executor/FlowExecutor.d.ts

@@ -12,12 +12,13 @@ import type { DispatchEventOptions } from '../types';
 export declare class FlowExecutor {
     private readonly engine;
     constructor(engine: FlowEngine);
+    private emitModelEventIf;
     /** Cache wrapper for applyFlow cache lifecycle */
     private withApplyFlowCache;
     /**
      * Execute a single flow on model.
      */
-    runFlow(model: FlowModel, flowKey: string, inputArgs?: Record<string, any>, runId?: string): Promise<any>;
+    runFlow(model: FlowModel, flowKey: string, inputArgs?: Record<string, any>, runId?: string, eventName?: string): Promise<any>;
     /**
      * Dispatch an event to flows bound via flow.on and execute them.
      */

package/lib/executor/FlowExecutor.js

@@ -51,6 +51,10 @@ const _FlowExecutor = class _FlowExecutor {
   constructor(engine) {
     this.engine = engine;
   }
+  async emitModelEventIf(eventName, topic, payload) {
+    if (!eventName) return;
+    await this.engine.emitter.emitAsync(`model:event:${eventName}:${topic}`, payload);
+  }
   /** Cache wrapper for applyFlow cache lifecycle */
   async withApplyFlowCache(cacheKey, executor) {
     if (!cacheKey || !this.engine) return await executor();
@@ -81,7 +85,7 @@ const _FlowExecutor = class _FlowExecutor {
   /**
    * Execute a single flow on model.
    */
-  async runFlow(model, flowKey, inputArgs, runId) {
+  async runFlow(model, flowKey, inputArgs, runId, eventName) {
     var _a;
     const flow = model.getFlow(flowKey);
     if (!flow) {
@@ -113,6 +117,14 @@ const _FlowExecutor = class _FlowExecutor {
     const stepDefs = eventStep ? { eventStep, ...flow.steps } : flow.steps;
     (0, import_setupRuntimeContextSteps.setupRuntimeContextSteps)(flowContext, stepDefs, model, flowKey);
     const stepsRuntime = flowContext.steps;
+    const flowEventBasePayload = {
+      uid: model.uid,
+      model,
+      runId: flowContext.runId,
+      inputArgs,
+      flowKey
+    };
+    await this.emitModelEventIf(eventName, `flow:${flowKey}:start`, flowEventBasePayload);
     for (const [stepKey, step] of Object.entries(stepDefs)) {
       let handler;
       let combinedParams = {};
@@ -163,20 +175,56 @@ const _FlowExecutor = class _FlowExecutor {
           );
           continue;
         }
+        await this.emitModelEventIf(eventName, `flow:${flowKey}:step:${stepKey}:start`, {
+          ...flowEventBasePayload,
+          stepKey
+        });
         const currentStepResult = handler(runtimeCtx, combinedParams);
         const isAwait = step.isAwait !== false;
         lastResult = isAwait ? await currentStepResult : currentStepResult;
         stepResults[stepKey] = lastResult;
         stepsRuntime[stepKey].result = stepResults[stepKey];
+        await this.emitModelEventIf(eventName, `flow:${flowKey}:step:${stepKey}:end`, {
+          ...flowEventBasePayload,
+          result: lastResult,
+          stepKey
+        });
       } catch (error) {
+        if (!(error instanceof import_utils.FlowExitException) && !(error instanceof import_exceptions.FlowExitAllException)) {
+          await this.emitModelEventIf(eventName, `flow:${flowKey}:step:${stepKey}:error`, {
+            ...flowEventBasePayload,
+            error,
+            stepKey
+          });
+        }
         if (error instanceof import_utils.FlowExitException) {
           flowContext.logger.info(`[FlowEngine] ${error.message}`);
+          await this.emitModelEventIf(eventName, `flow:${flowKey}:step:${stepKey}:end`, {
+            ...flowEventBasePayload,
+            stepKey
+          });
+          await this.emitModelEventIf(eventName, `flow:${flowKey}:end`, {
+            ...flowEventBasePayload,
+            result: stepResults
+          });
           return Promise.resolve(stepResults);
         }
         if (error instanceof import_exceptions.FlowExitAllException) {
           flowContext.logger.info(`[FlowEngine] ${error.message}`);
+          await this.emitModelEventIf(eventName, `flow:${flowKey}:step:${stepKey}:end`, {
+            ...flowEventBasePayload,
+            stepKey
+          });
+          await this.emitModelEventIf(eventName, `flow:${flowKey}:end`, {
+            ...flowEventBasePayload,
+            result: error
+          });
           return Promise.resolve(error);
         }
+        await this.emitModelEventIf(eventName, `flow:${flowKey}:error`, {
+          ...flowEventBasePayload,
+          error
+        });
         flowContext.logger.error(
           { err: error },
           `BaseModel.applyFlow: Error executing step '${stepKey}' in flow '${flowKey}':`
@@ -184,9 +232,12 @@ const _FlowExecutor = class _FlowExecutor {
         return Promise.reject(error);
       }
     }
+    await this.emitModelEventIf(eventName, `flow:${flowKey}:end`, {
+      ...flowEventBasePayload,
+      result: stepResults
+    });
     return Promise.resolve(stepResults);
   }
-  // runAutoFlows 已移除：统一通过 dispatchEvent('beforeRender') + useCache 控制
   /**
    * Dispatch an event to flows bound via flow.on and execute them.
    */
@@ -198,13 +249,14 @@ const _FlowExecutor = class _FlowExecutor {
     const throwOnError = isBeforeRender;
     const runId = `${model.uid}-${eventName}-${Date.now()}`;
     const logger = model.context.logger;
+    const eventBasePayload = {
+      uid: model.uid,
+      model,
+      runId,
+      inputArgs
+    };
     try {
-      await this.engine.emitter.emitAsync(`model:event:${eventName}:start`, {
-        uid: model.uid,
-        model,
-        runId,
-        inputArgs
-      });
+      await this.emitModelEventIf(eventName, "start", eventBasePayload);
       await ((_a = model.onDispatchEventStart) == null ? void 0 : _a.call(model, eventName, options, inputArgs));
     } catch (err) {
       if (isBeforeRender && err instanceof import_utils.FlowExitException) {
@@ -226,9 +278,17 @@ const _FlowExecutor = class _FlowExecutor {
       if (typeof on === "object") return on.eventName === eventName;
       return false;
     });
+    const isRouterReplayClick = eventName === "click" && (inputArgs == null ? void 0 : inputArgs.triggerByRouter) === true;
+    const flowsToRun = isRouterReplayClick ? flows.filter((flow) => {
+      var _a2;
+      const reg = flow["flowRegistry"];
+      const type = (_a2 = reg == null ? void 0 : reg.constructor) == null ? void 0 : _a2._type;
+      return type !== "instance";
+    }) : flows;
+    const scheduledCancels = [];
     const execute = /* @__PURE__ */ __name(async () => {
       if (sequential) {
-        const flowsWithIndex = flows.map((f, i) => ({ f, i }));
+        const flowsWithIndex = flowsToRun.map((f, i) => ({ f, i }));
         const ordered = flowsWithIndex.slice().sort((a, b) => {
           var _a2, _b2;
           const regA = a.f["flowRegistry"];
@@ -244,18 +304,101 @@ const _FlowExecutor = class _FlowExecutor {
           return a.i - b.i;
         }).map((x) => x.f);
         const results2 = [];
+        const staticFlowsByKey = new Map(
+          ordered.filter((f) => {
+            var _a2;
+            const reg = f["flowRegistry"];
+            const type = (_a2 = reg == null ? void 0 : reg.constructor) == null ? void 0 : _a2._type;
+            return type !== "instance";
+          }).map((f) => [f.key, f])
+        );
+        const scheduled = /* @__PURE__ */ new Set();
+        const scheduleGroups = /* @__PURE__ */ new Map();
+        ordered.forEach((flow, indexInOrdered) => {
+          var _a2;
+          const on = flow.on;
+          const onObj = typeof on === "object" ? on : void 0;
+          if (!onObj) return;
+          const phase = onObj.phase;
+          const flowKey = onObj.flowKey;
+          const stepKey = onObj.stepKey;
+          if (!phase || phase === "beforeAllFlows") return;
+          let whenKey = null;
+          if (phase === "afterAllFlows") {
+            whenKey = `event:${eventName}:end`;
+          } else if (phase === "beforeFlow" || phase === "afterFlow") {
+            if (!flowKey) {
+              whenKey = `event:${eventName}:end`;
+            } else {
+              const anchorFlow = staticFlowsByKey.get(String(flowKey));
+              if (anchorFlow) {
+                const anchorPhase = phase === "beforeFlow" ? "start" : "end";
+                whenKey = `event:${eventName}:flow:${String(flowKey)}:${anchorPhase}`;
+              } else {
+                whenKey = `event:${eventName}:end`;
+              }
+            }
+          } else if (phase === "beforeStep" || phase === "afterStep") {
+            if (!flowKey || !stepKey) {
+              whenKey = `event:${eventName}:end`;
+            } else {
+              const anchorFlow = staticFlowsByKey.get(String(flowKey));
+              const anchorStepExists = !!((_a2 = anchorFlow == null ? void 0 : anchorFlow.hasStep) == null ? void 0 : _a2.call(anchorFlow, String(stepKey)));
+              if (anchorFlow && anchorStepExists) {
+                const anchorPhase = phase === "beforeStep" ? "start" : "end";
+                whenKey = `event:${eventName}:flow:${String(flowKey)}:step:${String(stepKey)}:${anchorPhase}`;
+              } else {
+                whenKey = `event:${eventName}:end`;
+              }
+            }
+          } else {
+            return;
+          }
+          if (!whenKey) return;
+          scheduled.add(flow.key);
+          const list = scheduleGroups.get(whenKey) || [];
+          list.push({ flow, order: indexInOrdered });
+          scheduleGroups.set(whenKey, list);
+        });
+        for (const [whenKey, list] of scheduleGroups.entries()) {
+          const sorted = list.slice().sort((a, b) => {
+            const sa = a.flow.sort ?? 0;
+            const sb = b.flow.sort ?? 0;
+            if (sa !== sb) return sa - sb;
+            return a.order - b.order;
+          });
+          for (const it of sorted) {
+            const cancel = model.scheduleModelOperation(
+              model.uid,
+              async (m) => {
+                const res = await this.runFlow(m, it.flow.key, inputArgs, runId, eventName);
+                if (res instanceof import_exceptions.FlowExitAllException) {
+                  throw res;
+                }
+                results2.push(res);
+              },
+              { when: whenKey }
+            );
+            scheduledCancels.push(cancel);
+          }
+        }
         for (const flow of ordered) {
+          if (scheduled.has(flow.key)) continue;
           try {
             logger.debug(
               `BaseModel '${model.uid}' dispatching event '${eventName}' to flow '${flow.key}' (sequential).`
             );
-            const result = await this.runFlow(model, flow.key, inputArgs, runId);
+            const result = await this.runFlow(model, flow.key, inputArgs, runId, eventName);
             if (result instanceof import_exceptions.FlowExitAllException) {
               logger.debug(`[FlowEngine.dispatchEvent] ${result.message}`);
               break;
             }
             results2.push(result);
           } catch (error) {
+            if (error instanceof import_exceptions.FlowExitAllException) {
+              logger.debug(`[FlowEngine.dispatchEvent] ${error.message}`);
+              break;
+            }
             logger.error(
               { err: error },
               `BaseModel.dispatchEvent: Error executing event-triggered flow '${flow.key}' for event '${eventName}' (sequential):`
@@ -266,10 +409,10 @@ const _FlowExecutor = class _FlowExecutor {
         return results2;
       }
       const results = await Promise.all(
-        flows.map(async (flow) => {
+        flowsToRun.map(async (flow) => {
           logger.debug(`BaseModel '${model.uid}' dispatching event '${eventName}' to flow '${flow.key}'.`);
           try {
-            return await this.runFlow(model, flow.key, inputArgs, runId);
+            return await this.runFlow(model, flow.key, inputArgs, runId, eventName);
           } catch (error) {
             logger.error(
               { err: error },
@@ -295,11 +438,8 @@ const _FlowExecutor = class _FlowExecutor {
       } catch (hookErr) {
         logger.error({ err: hookErr }, `BaseModel.dispatchEvent: End hook error for event '${eventName}'`);
       }
-      await this.engine.emitter.emitAsync(`model:event:${eventName}:end`, {
-        uid: model.uid,
-        model,
-        runId,
-        inputArgs,
+      await this.emitModelEventIf(eventName, "end", {
+        ...eventBasePayload,
         result
       });
       return result;
@@ -312,14 +452,15 @@ const _FlowExecutor = class _FlowExecutor {
         { err: error },
         `BaseModel.dispatchEvent: Error executing event '${eventName}' for model '${model.uid}':`
       );
-      await this.engine.emitter.emitAsync(`model:event:${eventName}:error`, {
-        uid: model.uid,
-        model,
-        runId,
-        inputArgs,
+      await this.emitModelEventIf(eventName, "error", {
+        ...eventBasePayload,
         error
       });
       if (throwOnError) throw error;
+    } finally {
+      for (const cancel of scheduledCancels) {
+        cancel();
+      }
     }
   }
 };