@nocobase/flow-engine 2.0.0-alpha.2 → 2.0.0-alpha.20

package/lib/components/variables/VariableInput.js

@@ -94,6 +94,7 @@ const VariableInputComponent = /* @__PURE__ */ __name(({
   showValueComponent = true,
   onlyLeafSelectable = false,
   clearValue,
+  ignoreFieldNames,
   ...restProps
 }) => {
   const [currentMetaTreeNode, setCurrentMetaTreeNode] = (0, import_react.useState)(null);
@@ -241,11 +242,23 @@ const VariableInputComponent = /* @__PURE__ */ __name(({
     if (disabled) {
       return;
     }
-    setCurrentMetaTreeNode(null);
     const cleared = clearValue !== void 0 ? clearValue : null;
     setInnerValue(cleared);
+    try {
+      const path = resolvePathFromValue == null ? void 0 : resolvePathFromValue(cleared);
+      if (Array.isArray(resolvedMetaTree) && path && path.length > 0) {
+        const node = findMetaTreeNodeByPath(resolvedMetaTree, path);
+        if (node) {
+          setCurrentMetaTreeNode(node);
+          emitChange(cleared, node);
+          return;
+        }
+      }
+    } catch (_) {
+    }
+    setCurrentMetaTreeNode(null);
     emitChange(cleared);
-  }, [emitChange, disabled, clearValue]);
+  }, [emitChange, disabled, clearValue, resolvedMetaTree, resolvePathFromValue]);
   const stableProps = (0, import_react.useMemo)(() => {
     const { style, onFocus, onBlur, disabled: disabled2, ...otherProps } = restProps;
     return { style, onFocus, onBlur, otherProps };
@@ -311,6 +324,7 @@ const VariableInputComponent = /* @__PURE__ */ __name(({
       parseValueToPath: resolvePathFromValue,
       formatPathToValue: resolveValueFromPath,
       onlyLeafSelectable,
+      ignoreFieldNames,
       ...!showValueComponent && { children: null, placeholder: restProps == null ? void 0 : restProps.placeholder }
     }
   ));

package/lib/components/variables/VariableTag.js

@@ -63,8 +63,49 @@ const VariableTagComponent = /* @__PURE__ */ __name(({
         return metaTreeNode.parentTitles ? [...metaTreeNode.parentTitles, metaTreeNode.title].map(ctx.t).join("/") : ctx.t(metaTreeNode.title) || "";
       }
       if (!value) return String(value);
-      const path = (0, import_utils.parseValueToPath)(value);
-      return path ? path.join("/") : String(value);
+      const rawPath = (0, import_utils.parseValueToPath)(value);
+      if (!rawPath || !Array.isArray(resolvedMetaTree)) {
+        return Array.isArray(rawPath) ? rawPath.join("/") : String(value);
+      }
+      const topNames = new Set((resolvedMetaTree || []).map((n) => String(n == null ? void 0 : n.name)));
+      const path = !topNames.has(String(rawPath[0])) ? rawPath.slice(1) : rawPath;
+      if (!path.length) return "";
+      let nodes = resolvedMetaTree;
+      let deepest = null;
+      let matchedCount = 0;
+      for (let i = 0; i < path.length; i++) {
+        if (!nodes) break;
+        const seg = String(path[i]);
+        const node = nodes.find((n) => String(n == null ? void 0 : n.name) === seg);
+        if (!node) break;
+        deepest = node;
+        matchedCount = i + 1;
+        if (i < path.length - 1) {
+          if (Array.isArray(node.children)) {
+            nodes = node.children;
+          } else if (typeof node.children === "function") {
+            try {
+              const childNodes = await node.children();
+              node.children = childNodes;
+              nodes = childNodes;
+            } catch {
+              nodes = void 0;
+            }
+          } else {
+            nodes = void 0;
+          }
+        }
+      }
+      if (deepest) {
+        const titles = deepest.parentTitles ? [...deepest.parentTitles, deepest.title] : [deepest.title];
+        let label = titles.map(ctx.t).join("/");
+        if (matchedCount < path.length) {
+          const tail = path.slice(matchedCount).join("/");
+          label = tail ? `${label}/${tail}` : label;
+        }
+        return label;
+      }
+      return path.join("/");
     },
     { refreshDeps: [resolvedMetaTree, value, metaTreeNode] }
   );

package/lib/components/variables/types.d.ts

@@ -18,6 +18,7 @@ export interface FlowContextSelectorProps extends Omit<CascaderProps<ContextSele
     formatPathToValue?: (item: MetaTreeNode) => string;
     open?: boolean;
     onlyLeafSelectable?: boolean;
+    ignoreFieldNames?: string[];
 }
 export interface ContextSelectorItem {
     label: React.ReactNode;
@@ -62,6 +63,7 @@ export interface VariableInputProps {
      * 默认行为为 null；可设置为 '' 等，以便清空后默认切换为“常量-空字符串”。
      */
     clearValue?: any;
+    ignoreFieldNames?: string[];
     [key: string]: any;
 }
 export interface VariableTagProps {

package/lib/data-source/index.d.ts

@@ -49,7 +49,9 @@ export declare class DataSource {
     addCollection(collection: Collection | CollectionOptions): void;
     updateCollection(newOptions: CollectionOptions): void;
     upsertCollection(options: CollectionOptions): Collection;
-    upsertCollections(collections: CollectionOptions[]): void;
+    upsertCollections(collections: CollectionOptions[], options?: {
+        clearFields?: boolean;
+    }): void;
     removeCollection(name: string): void;
     clearCollections(): void;
     setOptions(newOptions?: any): void;
@@ -68,9 +70,13 @@ export declare class CollectionManager {
     get flowEngine(): FlowEngine;
     addCollection(collection: Collection | CollectionOptions): void;
     removeCollection(name: string): void;
-    updateCollection(newOptions: CollectionOptions): void;
+    updateCollection(newOptions: CollectionOptions, options?: {
+        clearFields?: boolean;
+    }): void;
     upsertCollection(options: CollectionOptions): Collection;
-    upsertCollections(collections: CollectionOptions[]): void;
+    upsertCollections(collections: CollectionOptions[], options?: {
+        clearFields?: boolean;
+    }): void;
     sortCollectionsByInherits(collections: CollectionOptions[]): CollectionOptions[];
     getCollection(name: string): Collection | undefined;
     getCollections(): Collection[];
@@ -97,7 +103,9 @@ export declare class Collection {
     get titleCollectionField(): CollectionField;
     initInherits(): void;
     setDataSource(dataSource: DataSource): void;
-    setOptions(newOptions?: any): void;
+    setOptions(newOptions?: any, options?: {
+        clearFields?: boolean;
+    }): void;
     getFields(): CollectionField[];
     getToOneAssociationFields(): CollectionField[];
     getAssociationFields(types?: any[]): CollectionField[];

package/lib/data-source/index.js

@@ -49,6 +49,7 @@ module.exports = __toCommonJS(data_source_exports);
 var import_reactive = require("@formily/reactive");
 var import_lodash = __toESM(require("lodash"));
 var import_jioToJoiSchema = require("./jioToJoiSchema");
+var import_sortCollectionsByInherits = require("./sortCollectionsByInherits");
 const _DataSourceManager = class _DataSourceManager {
   dataSources;
   flowEngine;
@@ -152,8 +153,8 @@ const _DataSource = class _DataSource {
   upsertCollection(options) {
     return this.collectionManager.upsertCollection(options);
   }
-  upsertCollections(collections) {
-    return this.collectionManager.upsertCollections(collections);
+  upsertCollections(collections, options = {}) {
+    return this.collectionManager.upsertCollections(collections, options);
   }
   removeCollection(name) {
     return this.collectionManager.removeCollection(name);
@@ -204,12 +205,12 @@ const _CollectionManager = class _CollectionManager {
   removeCollection(name) {
     this.collections.delete(name);
   }
-  updateCollection(newOptions) {
+  updateCollection(newOptions, options = {}) {
     const collection = this.getCollection(newOptions.name);
     if (!collection) {
       throw new Error(`Collection ${newOptions.name} not found`);
     }
-    collection.setOptions(newOptions);
+    collection.setOptions(newOptions, options);
   }
   upsertCollection(options) {
     if (this.collections.has(options.name)) {
@@ -219,10 +220,10 @@ const _CollectionManager = class _CollectionManager {
     }
     return this.getCollection(options.name);
   }
-  upsertCollections(collections) {
-    for (const collection of this.sortCollectionsByInherits(collections)) {
+  upsertCollections(collections, options = {}) {
+    for (const collection of (0, import_sortCollectionsByInherits.sortCollectionsByInherits)(collections)) {
       if (this.collections.has(collection.name)) {
-        this.updateCollection(collection);
+        this.updateCollection(collection, options);
       } else {
         this.addCollection(collection);
       }
@@ -368,7 +369,8 @@ const _Collection = class _Collection {
     for (const inherit of this.options.inherits || []) {
       const collection = this.collectionManager.getCollection(inherit);
       if (!collection) {
-        throw new Error(`Collection ${inherit} not found`);
+        console.warn(`Warning: Collection ${inherit} not found for collection ${this.name}`);
+        continue;
       }
       this.inherits.set(inherit, collection);
     }
@@ -376,10 +378,13 @@ const _Collection = class _Collection {
   setDataSource(dataSource) {
     this.dataSource = dataSource;
   }
-  setOptions(newOptions = {}) {
+  setOptions(newOptions = {}, options = {}) {
     Object.keys(this.options).forEach((key) => delete this.options[key]);
     Object.assign(this.options, newOptions);
     this.initInherits();
+    if (options.clearFields) {
+      this.clearFields();
+    }
     this.upsertFields(this.options.fields || []);
   }
   getFields() {
@@ -584,7 +589,7 @@ const _CollectionField = class _CollectionField {
   }
   get title() {
     var _a, _b, _c;
-    const titleValue = ((_a = this.options) == null ? void 0 : _a.title) || ((_c = (_b = this.options) == null ? void 0 : _b.uiSchema) == null ? void 0 : _c.title) || this.options.name;
+    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);
   }
   set title(value) {
@@ -618,7 +623,7 @@ const _CollectionField = class _CollectionField {
     return this.options.validation;
   }
   getComponentProps() {
-    var _a;
+    var _a, _b;
     const { type, target } = this.options;
     const componentProps = import_lodash.default.omitBy(
       {
@@ -627,7 +632,8 @@ const _CollectionField = class _CollectionField {
         mode: this.type === "array" ? "multiple" : void 0,
         multiple: target ? ["belongsToMany", "hasMany", "belongsToArray"].includes(type) : void 0,
         maxCount: target && !["belongsToMany", "hasMany", "belongsToArray"].includes(type) ? 1 : void 0,
-        target
+        target,
+        template: (_b = this.targetCollection) == null ? void 0 : _b.template
       },
       import_lodash.default.isUndefined
     );

package/lib/data-source/sortCollectionsByInherits.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { CollectionOptions } from '.';
+export declare function sortCollectionsByInherits(collections: CollectionOptions[]): CollectionOptions[];

package/lib/data-source/sortCollectionsByInherits.js

@@ -0,0 +1,71 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sortCollectionsByInherits_exports = {};
+__export(sortCollectionsByInherits_exports, {
+  sortCollectionsByInherits: () => sortCollectionsByInherits
+});
+module.exports = __toCommonJS(sortCollectionsByInherits_exports);
+function sortCollectionsByInherits(collections) {
+  const sorted = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const map = /* @__PURE__ */ new Map();
+  collections.forEach((col) => {
+    map.set(col.name, col);
+  });
+  const addToSorted = /* @__PURE__ */ __name((col) => {
+    if (visiting.has(col.name)) {
+      throw new Error(`Circular dependency detected: ${col.name} inherits from itself through a chain`);
+    }
+    if (visited.has(col.name)) {
+      return;
+    }
+    visiting.add(col.name);
+    const inherits = col.inherits || [];
+    for (const inheritName of inherits) {
+      const inheritCol = map.get(inheritName);
+      if (!inheritCol) {
+        console.warn(`Warning: Collection ${inheritName}, inherited by ${col.name}, not found.`);
+        continue;
+      }
+      addToSorted(inheritCol);
+    }
+    visiting.delete(col.name);
+    visited.add(col.name);
+    sorted.push(col);
+  }, "addToSorted");
+  for (const col of collections) {
+    addToSorted(col);
+  }
+  return sorted;
+}
+__name(sortCollectionsByInherits, "sortCollectionsByInherits");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sortCollectionsByInherits
+});

package/lib/executor/FlowExecutor.d.ts

@@ -8,19 +8,18 @@
  */
 import { FlowEngine } from '../flowEngine';
 import type { FlowModel } from '../models';
+import type { DispatchEventOptions } from '../types';
 export declare class FlowExecutor {
     private readonly engine;
     constructor(engine: FlowEngine);
+    /** 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>;
-    /**
-     * Execute all auto-apply flows for model.
-     */
-    runAutoFlows(model: FlowModel, inputArgs?: Record<string, any>, useCache?: boolean): Promise<any[]>;
     /**
      * Dispatch an event to flows bound via flow.on and execute them.
      */
-    dispatchEvent(model: FlowModel, eventName: string, inputArgs?: Record<string, any>): Promise<void>;
+    dispatchEvent(model: FlowModel, eventName: string, inputArgs?: Record<string, any>, options?: DispatchEventOptions): Promise<any>;
 }

package/lib/executor/FlowExecutor.js

@@ -50,6 +50,33 @@ const _FlowExecutor = class _FlowExecutor {
   constructor(engine) {
     this.engine = engine;
   }
+  /** Cache wrapper for applyFlow cache lifecycle */
+  async withApplyFlowCache(cacheKey, executor) {
+    if (!cacheKey || !this.engine) return await executor();
+    const cachedEntry = this.engine.applyFlowCache.get(cacheKey);
+    if (cachedEntry) {
+      if (cachedEntry.status === "resolved") return cachedEntry.data;
+      if (cachedEntry.status === "rejected") throw cachedEntry.error;
+      if (cachedEntry.status === "pending") return await cachedEntry.promise;
+    }
+    const promise = executor().then((result) => {
+      this.engine.applyFlowCache.set(cacheKey, {
+        status: "resolved",
+        data: result,
+        promise: Promise.resolve(result)
+      });
+      return result;
+    }).catch((err) => {
+      this.engine.applyFlowCache.set(cacheKey, {
+        status: "rejected",
+        error: err,
+        promise: Promise.reject(err)
+      });
+      throw err;
+    });
+    this.engine.applyFlowCache.set(cacheKey, { status: "pending", promise });
+    return await promise;
+  }
   /**
    * Execute a single flow on model.
    */
@@ -77,20 +104,20 @@ const _FlowExecutor = class _FlowExecutor {
     let eventStep = model.getEvent(typeof flow.on === "string" ? flow.on : (_a = flow.on) == null ? void 0 : _a.eventName);
     if (eventStep) {
       eventStep = { ...eventStep };
-      eventStep.defaultParams = { ...import_lodash.default.get(flow, "on.defaultParams", {}), ...eventStep.defaultParams };
+      eventStep.defaultParams = {
+        ...import_lodash.default.get(flow, "on.defaultParams", {}),
+        ...eventStep.defaultParams
+      };
     }
     const stepDefs = eventStep ? { eventStep, ...flow.steps } : flow.steps;
     (0, import_setupRuntimeContextSteps.setupRuntimeContextSteps)(flowContext, stepDefs, model, flowKey);
     const stepsRuntime = flowContext.steps;
-    for (const stepKey in stepDefs) {
-      if (!Object.prototype.hasOwnProperty.call(stepDefs, stepKey)) continue;
-      const step = stepDefs[stepKey];
+    for (const [stepKey, step] of Object.entries(stepDefs)) {
       let handler;
       let combinedParams = {};
-      let actionDefinition;
       let useRawParams = step.useRawParams;
       if (step.use) {
-        actionDefinition = model.getAction(step.use);
+        const actionDefinition = model.getAction(step.use);
         if (!actionDefinition) {
           flowContext.logger.error(
             `BaseModel.applyFlow: Action '${step.use}' not found for step '${stepKey}' in flow '${flowKey}'. Skipping.`
@@ -152,106 +179,107 @@ const _FlowExecutor = class _FlowExecutor {
     }
     return Promise.resolve(stepResults);
   }
+  // runAutoFlows 已移除：统一通过 dispatchEvent('beforeRender') + useCache 控制
   /**
-   * Execute all auto-apply flows for model.
+   * Dispatch an event to flows bound via flow.on and execute them.
    */
-  async runAutoFlows(model, inputArgs, useCache = true) {
-    const autoApplyFlows = model.getAutoFlows();
-    if (autoApplyFlows.length === 0) {
-      model.context.logger.warn(`FlowModel: No auto-apply flows found for model '${model.uid}'`);
-      return [];
-    }
-    const cacheKey = useCache ? import_flowEngine.FlowEngine.generateApplyFlowCacheKey(model.getAutoFlowCacheScope(), "all", model.uid) : null;
-    if (cacheKey && this.engine) {
-      const cachedEntry = this.engine.applyFlowCache.get(cacheKey);
-      if (cachedEntry) {
-        if (cachedEntry.status === "resolved") {
-          model.context.logger.debug(`[FlowEngine.applyAutoFlows] Using cached result for model: ${model.uid}`);
-          return cachedEntry.data;
-        }
-        if (cachedEntry.status === "rejected") throw cachedEntry.error;
-        if (cachedEntry.status === "pending") return await cachedEntry.promise;
+  async dispatchEvent(model, eventName, inputArgs, options) {
+    var _a, _b, _c, _d;
+    const isBeforeRender = eventName === "beforeRender";
+    const sequential = !!(options == null ? void 0 : options.sequential);
+    const useCache = !!(options == null ? void 0 : options.useCache);
+    const throwOnError = isBeforeRender;
+    const runId = `${model.uid}-${eventName}-${Date.now()}`;
+    const logger = model.context.logger;
+    try {
+      await ((_a = model.onDispatchEventStart) == null ? void 0 : _a.call(model, eventName, options, inputArgs));
+    } catch (err) {
+      if (isBeforeRender && err instanceof import_utils.FlowExitException) {
+        logger.debug(`[FlowModel.dispatchEvent] ${err.message}`);
+        return [];
       }
-    }
-    const executeAutoFlows = /* @__PURE__ */ __name(async () => {
-      const results = [];
-      const runId = `${model.uid}-autoFlow-${Date.now()}-${Math.floor(Math.random() * 1e3)}`;
-      const logger = model.context.logger.child({ module: "flow-engine", component: "FlowExecutor", runId });
-      logger.debug(
-        `[FlowExecutor] runAutoFlows: uid=${model.uid}, isFork=${(model == null ? void 0 : model.isFork) === true}, useCache=${useCache}, runId=${runId}, flows=${autoApplyFlows.map((f) => f.key).join(",")}`
-      );
       try {
-        if (autoApplyFlows.length === 0) {
-          logger.warn(`FlowModel: No auto-apply flows found for model '${model.uid}'`);
-        } else {
-          for (const flow of autoApplyFlows) {
-            try {
-              logger.debug(`[FlowExecutor] runFlow: uid=${model.uid}, flowKey=${flow.key}`);
-              const result = await this.runFlow(model, flow.key, inputArgs, runId);
-              if (result instanceof import_exceptions.FlowExitAllException) {
-                logger.debug(`[FlowEngine.applyAutoFlows] ${result.message}`);
-                break;
-              }
-              results.push(result);
-            } catch (error) {
-              logger.error({ err: error }, `FlowModel.applyAutoFlows: Error executing auto-apply flow '${flow.key}':`);
-              throw error;
-            }
-          }
-        }
-        return results;
-      } catch (error) {
-        if (error instanceof import_utils.FlowExitException) {
-          logger.debug(`[FlowEngine.applyAutoFlows] ${error.message}`);
-          return results;
-        }
-        throw error;
+        await ((_b = model.onDispatchEventError) == null ? void 0 : _b.call(model, eventName, options, inputArgs, err));
+      } finally {
+        logger.error({ err }, `BaseModel.dispatchEvent: Start hook error for event '${eventName}'`);
       }
-    }, "executeAutoFlows");
-    if (!cacheKey || !this.engine) {
-      return await executeAutoFlows();
+      if (throwOnError) throw err;
+      return;
     }
-    const promise = executeAutoFlows().then((result) => {
-      this.engine.applyFlowCache.set(cacheKey, {
-        status: "resolved",
-        data: result,
-        promise: Promise.resolve(result)
-      });
-      return result;
-    }).catch((err) => {
-      this.engine.applyFlowCache.set(cacheKey, {
-        status: "rejected",
-        error: err,
-        promise: Promise.reject(err)
-      });
-      throw err;
-    });
-    this.engine.applyFlowCache.set(cacheKey, { status: "pending", promise });
-    return await promise;
-  }
-  /**
-   * Dispatch an event to flows bound via flow.on and execute them.
-   */
-  async dispatchEvent(model, eventName, inputArgs) {
-    const flows = Array.from(model.getFlows().values()).filter((flow) => {
+    const flows = isBeforeRender ? model.getEventFlows("beforeRender") : Array.from(model.getFlows().values()).filter((flow) => {
       const on = flow.on;
       if (!on) return false;
       if (typeof on === "string") return on === eventName;
       if (typeof on === "object") return on.eventName === eventName;
       return false;
     });
-    const runId = `${model.uid}-${eventName}-${Date.now()}`;
-    const logger = model.context.logger;
-    const promises = flows.map((flow) => {
-      logger.debug(`BaseModel '${model.uid}' dispatching event '${eventName}' to flow '${flow.key}'.`);
-      return this.runFlow(model, flow.key, inputArgs, runId).catch((error) => {
-        logger.error(
-          { err: error },
-          `BaseModel.dispatchEvent: Error executing event-triggered flow '${flow.key}' for event '${eventName}':`
-        );
-      });
-    });
-    await Promise.all(promises);
+    const execute = /* @__PURE__ */ __name(async () => {
+      if (sequential) {
+        const ordered = flows.slice().sort((a, b) => (a.sort ?? 0) - (b.sort ?? 0));
+        const results2 = [];
+        for (const flow of ordered) {
+          try {
+            logger.debug(
+              `BaseModel '${model.uid}' dispatching event '${eventName}' to flow '${flow.key}' (sequential).`
+            );
+            const result = await this.runFlow(model, flow.key, inputArgs, runId);
+            if (result instanceof import_exceptions.FlowExitAllException) {
+              logger.debug(`[FlowEngine.dispatchEvent] ${result.message}`);
+              break;
+            }
+            results2.push(result);
+          } catch (error) {
+            logger.error(
+              { err: error },
+              `BaseModel.dispatchEvent: Error executing event-triggered flow '${flow.key}' for event '${eventName}' (sequential):`
+            );
+            throw error;
+          }
+        }
+        return results2;
+      }
+      const results = await Promise.all(
+        flows.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);
+          } catch (error) {
+            logger.error(
+              { err: error },
+              `BaseModel.dispatchEvent: Error executing event-triggered flow '${flow.key}' for event '${eventName}':`
+            );
+            if (throwOnError) throw error;
+            return void 0;
+          }
+        })
+      );
+      return results.filter((x) => x !== void 0);
+    }, "execute");
+    const argsKey = useCache ? JSON.stringify(inputArgs ?? {}) : "";
+    const cacheKey = useCache ? import_flowEngine.FlowEngine.generateApplyFlowCacheKey(
+      `event:${model.getFlowCacheScope(eventName)}:${argsKey}`,
+      eventName,
+      model.uid
+    ) : null;
+    try {
+      const result = await this.withApplyFlowCache(cacheKey, execute);
+      try {
+        await ((_c = model.onDispatchEventEnd) == null ? void 0 : _c.call(model, eventName, options, inputArgs, result));
+      } catch (hookErr) {
+        logger.error({ err: hookErr }, `BaseModel.dispatchEvent: End hook error for event '${eventName}'`);
+      }
+      return result;
+    } catch (error) {
+      try {
+        await ((_d = model.onDispatchEventError) == null ? void 0 : _d.call(model, eventName, options, inputArgs, error));
+      } catch (_2) {
+      }
+      model.context.logger.error(
+        { err: error },
+        `BaseModel.dispatchEvent: Error executing event '${eventName}' for model '${model.uid}':`
+      );
+      if (throwOnError) throw error;
+    }
   }
 };
 __name(_FlowExecutor, "FlowExecutor");