@nocobase/flow-engine 2.0.0-alpha.36 → 2.0.0-alpha.37

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

@@ -82,6 +82,7 @@ export declare class CollectionManager {
     getCollections(): Collection[];
     clearCollections(): void;
     getAssociation(associationName: string): CollectionField | undefined;
+    getChildrenCollections(name: any): any[];
 }
 export declare class Collection {
     fields: Map<string, CollectionField>;

package/lib/data-source/index.js

@@ -300,6 +300,23 @@ const _CollectionManager = class _CollectionManager {
     }
     return collection.getField(fieldName);
   }
+  getChildrenCollections(name) {
+    const childrens = [];
+    const collections = Array.from(this.collections.values());
+    const getChildrens = /* @__PURE__ */ __name((name2) => {
+      const inheritCollections = collections.filter((v) => {
+        var _a;
+        return (_a = v.options.inherits) == null ? void 0 : _a.includes(name2);
+      });
+      inheritCollections.forEach((v) => {
+        const collectionKey = v.name;
+        childrens.push(v);
+        return getChildrens(collectionKey);
+      });
+      return childrens;
+    }, "getChildrens");
+    return getChildrens(name);
+  }
 };
 __name(_CollectionManager, "CollectionManager");
 let CollectionManager = _CollectionManager;

package/lib/executor/FlowExecutor.js

@@ -228,7 +228,21 @@ const _FlowExecutor = class _FlowExecutor {
     });
     const execute = /* @__PURE__ */ __name(async () => {
       if (sequential) {
-        const ordered = flows.slice().sort((a, b) => (a.sort ?? 0) - (b.sort ?? 0));
+        const flowsWithIndex = flows.map((f, i) => ({ f, i }));
+        const ordered = flowsWithIndex.slice().sort((a, b) => {
+          var _a2, _b2;
+          const regA = a.f["flowRegistry"];
+          const regB = b.f["flowRegistry"];
+          const typeA = (_a2 = regA == null ? void 0 : regA.constructor) == null ? void 0 : _a2._type;
+          const typeB = (_b2 = regB == null ? void 0 : regB.constructor) == null ? void 0 : _b2._type;
+          const groupA = typeA === "instance" ? 0 : 1;
+          const groupB = typeB === "instance" ? 0 : 1;
+          if (groupA !== groupB) return groupA - groupB;
+          const sa = a.f.sort ?? 0;
+          const sb = b.f.sort ?? 0;
+          if (sa !== sb) return sa - sb;
+          return a.i - b.i;
+        }).map((x) => x.f);
         const results2 = [];
         for (const flow of ordered) {
           try {

package/lib/flow-registry/GlobalFlowRegistry.d.ts

@@ -12,6 +12,7 @@ import { BaseFlowRegistry } from './BaseFlowRegistry';
 type FlowKey = string;
 export declare class GlobalFlowRegistry extends BaseFlowRegistry {
     protected target: ModelConstructor;
+    static readonly _type: "global";
     constructor(target: ModelConstructor);
     removeFlow(flowKey: FlowKey): void;
     getFlow(flowKey: FlowKey): FlowDefinition | undefined;

package/lib/flow-registry/GlobalFlowRegistry.js

@@ -11,6 +11,7 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
@@ -25,6 +26,7 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 var GlobalFlowRegistry_exports = {};
 __export(GlobalFlowRegistry_exports, {
   GlobalFlowRegistry: () => GlobalFlowRegistry
@@ -88,6 +90,7 @@ const _GlobalFlowRegistry = class _GlobalFlowRegistry extends import_BaseFlowReg
   }
 };
 __name(_GlobalFlowRegistry, "GlobalFlowRegistry");
+__publicField(_GlobalFlowRegistry, "_type", "global");
 let GlobalFlowRegistry = _GlobalFlowRegistry;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/flow-registry/InstanceFlowRegistry.d.ts

@@ -12,6 +12,7 @@ import { BaseFlowRegistry } from './BaseFlowRegistry';
 type FlowKey = string;
 export declare class InstanceFlowRegistry extends BaseFlowRegistry {
     protected model: FlowModel;
+    static readonly _type: "instance";
     constructor(model: FlowModel);
     save(): Promise<void>;
     saveFlow(flow: FlowDefinition): Promise<void>;

package/lib/flow-registry/InstanceFlowRegistry.js

@@ -11,6 +11,7 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
@@ -25,6 +26,7 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 var InstanceFlowRegistry_exports = {};
 __export(InstanceFlowRegistry_exports, {
   InstanceFlowRegistry: () => InstanceFlowRegistry
@@ -52,6 +54,7 @@ const _InstanceFlowRegistry = class _InstanceFlowRegistry extends import_BaseFlo
   }
 };
 __name(_InstanceFlowRegistry, "InstanceFlowRegistry");
+__publicField(_InstanceFlowRegistry, "_type", "instance");
 let InstanceFlowRegistry = _InstanceFlowRegistry;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/flowContext.d.ts

@@ -146,6 +146,9 @@ declare class BaseFlowEngineContext extends FlowContext {
     requireAsync: (url: string) => Promise<any>;
     importAsync: (url: string) => Promise<any>;
     createJSRunner: (options?: JSRunnerOptions) => JSRunner;
+    pageInfo: {
+        version?: 'v1' | 'v2';
+    };
     /**
      * @deprecated use `resolveJsonTemplate` instead
      */

package/lib/models/flowModel.js

@@ -532,14 +532,15 @@ const _FlowModel = class _FlowModel {
     const instanceKeys = new Set(instanceFlows.keys());
     const staticEntries = Array.from(staticFlows.entries()).filter(([key]) => !instanceKeys.has(key));
     const instanceEntries = Array.from(instanceFlows.entries());
-    const allEntries = [...staticEntries, ...instanceEntries];
-    allEntries.sort(([, a], [, b]) => {
-      const sa = a.sort ?? 0;
-      const sb = b.sort ?? 0;
+    const instanceEntriesWithIndex = instanceEntries.map((e, i) => ({ e, i }));
+    instanceEntriesWithIndex.sort((a, b) => {
+      const sa = a.e[1].sort ?? 0;
+      const sb = b.e[1].sort ?? 0;
       if (sa !== sb) return sa - sb;
-      return 0;
+      return a.i - b.i;
     });
-    return new Map(allEntries);
+    const merged = [...instanceEntriesWithIndex.map(({ e }) => e), ...staticEntries];
+    return new Map(merged);
   }
   setProps(props, value) {
     if (typeof props === "string") {
@@ -611,7 +612,7 @@ const _FlowModel = class _FlowModel {
   }
   async dispatchEvent(eventName, inputArgs, options) {
     const isBeforeRender = eventName === "beforeRender";
-    const defaults = isBeforeRender ? { sequential: true, useCache: true } : {};
+    const defaults = isBeforeRender ? { sequential: true, useCache: true } : { sequential: true };
     const execOptions = {
       sequential: (options == null ? void 0 : options.sequential) ?? defaults.sequential,
       useCache: (options == null ? void 0 : options.useCache) ?? defaults.useCache

package/lib/utils/flows.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 { FlowDefinition } from '../FlowDefinition';
+export declare const isBeforeRenderFlow: (flow: FlowDefinition) => boolean;

package/lib/utils/flows.js

@@ -0,0 +1,48 @@
+/**
+ * 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 flows_exports = {};
+__export(flows_exports, {
+  isBeforeRenderFlow: () => isBeforeRenderFlow
+});
+module.exports = __toCommonJS(flows_exports);
+const isBeforeRenderFlow = /* @__PURE__ */ __name((flow) => {
+  if (typeof flow.on === "string") {
+    return flow.on === "beforeRender";
+  }
+  if (typeof flow.on === "object") {
+    return flow.on.eventName === "beforeRender";
+  }
+  if (!flow.on && flow.manual !== true) {
+    return true;
+  }
+  return false;
+}, "isBeforeRenderFlow");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isBeforeRenderFlow
+});

package/lib/utils/index.d.ts

@@ -22,4 +22,6 @@ export { clearAutoFlowError, getAutoFlowError, setAutoFlowError, type AutoFlowEr
 export { parsePathnameToViewParams, type ViewParam } from './parsePathnameToViewParams';
 export { buildSettingsViewInputArgs } from './buildSettingsViewInputArgs';
 export { createSafeDocument, createSafeWindow, createSafeNavigator } from './safeGlobals';
+export { createEphemeralContext } from './createEphemeralContext';
 export { pruneFilter } from './pruneFilter';
+export { isBeforeRenderFlow } from './flows';

package/lib/utils/index.js

@@ -40,6 +40,7 @@ __export(utils_exports, {
   createAssociationSubpathResolver: () => import_associationObjectVariable.createAssociationSubpathResolver,
   createCollectionContextMeta: () => import_createCollectionContextMeta.createCollectionContextMeta,
   createCurrentRecordMetaFactory: () => import_variablesParams.createCurrentRecordMetaFactory,
+  createEphemeralContext: () => import_createEphemeralContext.createEphemeralContext,
   createRecordMetaFactory: () => import_variablesParams.createRecordMetaFactory,
   createSafeDocument: () => import_safeGlobals.createSafeDocument,
   createSafeNavigator: () => import_safeGlobals.createSafeNavigator,
@@ -53,6 +54,7 @@ __export(utils_exports, {
   getAutoFlowError: () => import_autoFlowError.getAutoFlowError,
   getT: () => import_translation.getT,
   inferRecordRef: () => import_variablesParams.inferRecordRef,
+  isBeforeRenderFlow: () => import_flows.isBeforeRenderFlow,
   isInheritedFrom: () => import_inheritance.isInheritedFrom,
   isVariableExpression: () => import_context.isVariableExpression,
   parsePathnameToViewParams: () => import_parsePathnameToViewParams.parsePathnameToViewParams,
@@ -83,7 +85,9 @@ var import_autoFlowError = require("./autoFlowError");
 var import_parsePathnameToViewParams = require("./parsePathnameToViewParams");
 var import_buildSettingsViewInputArgs = require("./buildSettingsViewInputArgs");
 var import_safeGlobals = require("./safeGlobals");
+var import_createEphemeralContext = require("./createEphemeralContext");
 var import_pruneFilter = require("./pruneFilter");
+var import_flows = require("./flows");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BLOCK_GROUP_CONFIGS,
@@ -100,6 +104,7 @@ var import_pruneFilter = require("./pruneFilter");
   createAssociationSubpathResolver,
   createCollectionContextMeta,
   createCurrentRecordMetaFactory,
+  createEphemeralContext,
   createRecordMetaFactory,
   createSafeDocument,
   createSafeNavigator,
@@ -113,6 +118,7 @@ var import_pruneFilter = require("./pruneFilter");
   getAutoFlowError,
   getT,
   inferRecordRef,
+  isBeforeRenderFlow,
   isInheritedFrom,
   isVariableExpression,
   parsePathnameToViewParams,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/flow-engine",
-  "version": "2.0.0-alpha.36",
+  "version": "2.0.0-alpha.37",
   "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.0.0-alpha.36",
-    "@nocobase/shared": "2.0.0-alpha.36",
+    "@nocobase/sdk": "2.0.0-alpha.37",
+    "@nocobase/shared": "2.0.0-alpha.37",
     "ahooks": "^3.7.2",
     "dompurify": "^3.0.2",
     "lodash": "^4.x",
@@ -35,5 +35,5 @@
   ],
   "author": "NocoBase Team",
   "license": "AGPL-3.0",
-  "gitHead": "c1170bac3ba2325b7420ce65e732c1ba8bbb7767"
+  "gitHead": "56e2dc3a83b8ca7afa97cfa71b37a43f2ec10396"
 }

package/src/data-source/index.ts

@@ -321,6 +321,23 @@ export class CollectionManager {
     }
     return collection.getField(fieldName);
   }
+
+  getChildrenCollections(name) {
+    const childrens = [];
+    const collections = Array.from(this.collections.values());
+    const getChildrens = (name) => {
+      const inheritCollections = collections.filter((v: any) => {
+        return v.options.inherits?.includes(name);
+      });
+      inheritCollections.forEach((v) => {
+        const collectionKey = v.name;
+        childrens.push(v);
+        return getChildrens(collectionKey);
+      });
+      return childrens;
+    };
+    return getChildrens(name);
+  }
 }
 
 // Collection 负责管理自己的 Field

package/src/executor/FlowExecutor.ts

@@ -240,7 +240,24 @@ export class FlowExecutor {
     // 组装执行函数（返回值用于缓存；beforeRender 返回 results:any[]，其它返回 true）
     const execute = async () => {
       if (sequential) {
-        const ordered = flows.slice().sort((a, b) => (a.sort ?? 0) - (b.sort ?? 0));
+        // 顺序执行：动态流（实例级）优先，其次静态流；各自组内再按 sort 升序，最后保持原始顺序稳定
+        const flowsWithIndex = flows.map((f, i) => ({ f, i }));
+        const ordered = flowsWithIndex
+          .slice()
+          .sort((a, b) => {
+            const regA = a.f['flowRegistry'] as any;
+            const regB = b.f['flowRegistry'] as any;
+            const typeA = regA?.constructor?._type as 'instance' | 'global' | undefined;
+            const typeB = regB?.constructor?._type as 'instance' | 'global' | undefined;
+            const groupA = typeA === 'instance' ? 0 : 1; // 实例=0，静态=1
+            const groupB = typeB === 'instance' ? 0 : 1;
+            if (groupA !== groupB) return groupA - groupB;
+            const sa = a.f.sort ?? 0;
+            const sb = b.f.sort ?? 0;
+            if (sa !== sb) return sa - sb;
+            return a.i - b.i; // 稳定排序：保持原有相对顺序
+          })
+          .map((x) => x.f);
         const results: any[] = [];
         for (const flow of ordered) {
           try {

package/src/flow-registry/GlobalFlowRegistry.ts

@@ -15,6 +15,7 @@ import { BaseFlowRegistry } from './BaseFlowRegistry';
 type FlowKey = string;
 
 export class GlobalFlowRegistry extends BaseFlowRegistry {
+  static readonly _type = 'global' as const;
   constructor(protected target: ModelConstructor) {
     super();
   }

package/src/flow-registry/InstanceFlowRegistry.ts

@@ -14,6 +14,7 @@ import { BaseFlowRegistry } from './BaseFlowRegistry';
 type FlowKey = string;
 
 export class InstanceFlowRegistry extends BaseFlowRegistry {
+  static readonly _type = 'instance' as const;
   constructor(protected model: FlowModel) {
     super();
   }

package/src/flow-registry/__tests__/globalFlowRegistry.test.ts

@@ -138,4 +138,58 @@ describe('GlobalFlowRegistry', () => {
     expect(staticHandler).toHaveBeenCalled();
     expect(instanceHandler).toHaveBeenCalled();
   });
+
+  test('getFlows returns instance (dynamic) flows before static flows with own internal ordering', () => {
+    const engine = new FlowEngine();
+    class OrderModel extends FlowModel {}
+    engine.registerModels({ OrderModel });
+
+    // Register static flows with various sort values
+    OrderModel.registerFlow({ key: 'staticLow', title: 'S-low', sort: -10, steps: {} });
+    OrderModel.registerFlow({ key: 'staticHigh', title: 'S-high', sort: 10, steps: {} });
+
+    const model = engine.createModel({ use: 'OrderModel' });
+
+    // Add instance flows with sort values that would normally interleave if sorted purely by sort
+    model.flowRegistry.addFlow('instMid', { title: 'I-mid', sort: 0, steps: {} });
+    model.flowRegistry.addFlow('instHigh', { title: 'I-high', sort: 5, steps: {} });
+
+    const keys = Array.from(model.getFlows().keys());
+    // Expect dynamic flows first (by sort inside group), then static flows (by their own ordering)
+    expect(keys).toEqual(['instMid', 'instHigh', 'staticLow', 'staticHigh']);
+  });
+
+  test('sequential dispatch runs instance flows before static flows regardless of static sort', async () => {
+    const engine = new FlowEngine();
+    class SeqModel extends FlowModel {}
+    engine.registerModels({ SeqModel });
+
+    const calls: string[] = [];
+
+    // Static flow with very low sort to try to run first if not grouped
+    SeqModel.registerFlow({
+      key: 'S',
+      on: { eventName: 'click' },
+      sort: -100,
+      steps: { s: { handler: async () => void calls.push('static') } as any },
+    });
+
+    const model = engine.createModel({ use: 'SeqModel' });
+
+    // Instance flows with sort greater than static
+    model.flowRegistry.addFlow('I1', {
+      on: { eventName: 'click' },
+      sort: 0,
+      steps: { i1: { handler: async () => void calls.push('inst1') } as any },
+    });
+    model.flowRegistry.addFlow('I2', {
+      on: { eventName: 'click' },
+      sort: 5,
+      steps: { i2: { handler: async () => void calls.push('inst2') } as any },
+    });
+
+    await model.dispatchEvent('click', undefined, { sequential: true });
+
+    expect(calls).toEqual(['inst1', 'inst2', 'static']);
+  });
 });

package/src/flowContext.ts

@@ -896,6 +896,7 @@ class BaseFlowEngineContext extends FlowContext {
   declare requireAsync: (url: string) => Promise<any>;
   declare importAsync: (url: string) => Promise<any>;
   declare createJSRunner: (options?: JSRunnerOptions) => JSRunner;
+  declare pageInfo: { version?: 'v1' | 'v2' };
   /**
    * @deprecated use `resolveJsonTemplate` instead
    */

package/src/models/__tests__/dispatchEvent.behavior.test.ts

@@ -0,0 +1,169 @@
+/**
+ * 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 { describe, test, expect } from 'vitest';
+import { FlowEngine } from '../../flowEngine';
+import { FlowModel } from '../../models/flowModel';
+
+describe('dispatchEvent behavior (defaults, parallel, errors)', () => {
+  test('non-beforeRender defaults to sequential execution and respects getEventFlows order', async () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+
+    const calls: string[] = [];
+
+    // Static flow with higher sort
+    M.registerFlow({
+      key: 'S',
+      on: { eventName: 'go' },
+      sort: 10,
+      steps: { s: { handler: async () => void calls.push('static') } as any },
+    });
+
+    const model = engine.createModel({ use: 'M' });
+
+    // Instance flows
+    model.registerFlow('I1', {
+      on: { eventName: 'go' },
+      sort: 0,
+      steps: { i1: { handler: async () => void calls.push('inst1') } as any },
+    });
+    model.registerFlow('I2', {
+      on: { eventName: 'go' },
+      sort: 5,
+      steps: { i2: { handler: async () => void calls.push('inst2') } as any },
+    });
+
+    // No options provided -> should default to sequential execution
+    await model.dispatchEvent('go');
+
+    // Expected order should match getEventFlows('go') order
+    const expected = model.getEventFlows('go').map((f) => f.key);
+    expect(calls).toEqual(expected.map((k) => (k === 'I1' ? 'inst1' : k === 'I2' ? 'inst2' : 'static')));
+  });
+
+  test('parallel mode (sequential=false) runs all and tolerates non-beforeRender errors', async () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+
+    const calls: string[] = [];
+
+    M.registerFlow({
+      key: 'S',
+      on: { eventName: 'go' },
+      sort: 1,
+      steps: { s: { handler: async () => 'static-ok' } as any },
+    });
+
+    const model = engine.createModel({ use: 'M' });
+
+    model.registerFlow('I1', {
+      on: { eventName: 'go' },
+      sort: 0,
+      steps: { i1: { handler: async () => (calls.push('inst1'), 'i1-ok') } as any },
+    });
+    model.registerFlow('I2', {
+      on: { eventName: 'go' },
+      sort: 2,
+      steps: { i2: { handler: async () => (calls.push('inst2'), 'i2-ok') } as any },
+    });
+    model.registerFlow('ERR', {
+      on: { eventName: 'go' },
+      sort: 3,
+      steps: {
+        e: {
+          handler: async () => {
+            calls.push('err');
+            throw new Error('boom');
+          },
+        } as any,
+      },
+    });
+
+    const results = await model.dispatchEvent('go', undefined, { sequential: false });
+
+    // All handlers ran; order is not guaranteed in parallel mode
+    expect(new Set(calls)).toEqual(new Set(['inst1', 'inst2', 'err']));
+    // The error flow returns undefined and is filtered out; others return stepResults objects
+    // Expect one result object per successful flow with its step key
+    expect(Array.isArray(results)).toBe(true);
+    const keys = (results as any[]).flatMap((o) => Object.keys(o));
+    expect(new Set(keys)).toEqual(new Set(['i1', 'i2', 's']));
+    const byKey = Object.assign({}, ...(results as any[]));
+    expect(byKey['i1']).toBe('i1-ok');
+    expect(byKey['i2']).toBe('i2-ok');
+    expect(byKey['s']).toBe('static-ok');
+  });
+
+  test('sequential non-beforeRender: stops subsequent flows on error', async () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+
+    const calls: string[] = [];
+    const model = engine.createModel({ use: 'M' });
+
+    model.registerFlow('I1', {
+      on: { eventName: 'go' },
+      sort: 0,
+      steps: { i1: { handler: async () => void calls.push('i1') } as any },
+    });
+    model.registerFlow('ERR', {
+      on: { eventName: 'go' },
+      sort: 1,
+      steps: {
+        e: {
+          handler: async () => {
+            throw new Error('X');
+          },
+        } as any,
+      },
+    });
+    model.registerFlow('I2', {
+      on: { eventName: 'go' },
+      sort: 2,
+      steps: { i2: { handler: async () => void calls.push('i2') } as any },
+    });
+
+    await model.dispatchEvent('go', undefined, { sequential: true }).catch(() => undefined);
+    // 只应执行第一个 flow，后续被中止
+    expect(calls).toEqual(['i1']);
+  });
+
+  test('beforeRender errors are thrown (sequential default)', async () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+
+    const calls: string[] = [];
+    const model = engine.createModel({ use: 'M' });
+
+    model.registerFlow('F1', {
+      on: 'beforeRender',
+      sort: 0,
+      steps: {
+        a: {
+          handler: async () => {
+            throw new Error('BR');
+          },
+        } as any,
+      },
+    });
+    model.registerFlow('F2', {
+      on: 'beforeRender',
+      sort: 1,
+      steps: { b: { handler: async () => void calls.push('b') } as any },
+    });
+
+    await expect(model.dispatchEvent('beforeRender', undefined, { useCache: false })).rejects.toThrow('BR');
+    expect(calls).toEqual([]);
+  });
+});

package/src/models/__tests__/flowModel.getFlows.sort.test.ts

@@ -22,7 +22,7 @@ describe('FlowModel.getFlows sorting and getEventFlows(beforeRender) order', ()
     model = new TestFlowModel({ flowEngine: fakeEngine } as any);
   });
 
-  test('getFlows returns Map ordered by sort ascending', () => {
+  test('getFlows returns dynamic(instance) flows first, each group ordered by sort ascending', () => {
     // class-level (static) flows
     TestFlowModel.registerFlow('flowA', { title: 'A', sort: 10, steps: {} });
     TestFlowModel.registerFlow('flowB', { title: 'B', sort: 5, steps: {} });
@@ -34,7 +34,8 @@ describe('FlowModel.getFlows sorting and getEventFlows(beforeRender) order', ()
     const flows = model.getFlows();
     const orderedKeys = Array.from(flows.keys());
 
-    expect(orderedKeys).toEqual(['flowD', 'flowB', 'flowC', 'flowA']);
+    // 动态流组：flowD(0), flowC(7)；静态流组：flowB(5), flowA(10)
+    expect(orderedKeys).toEqual(['flowD', 'flowC', 'flowB', 'flowA']);
   });
 
   test("getEventFlows('beforeRender') keeps getFlows order and filters out manual/on flows", () => {
@@ -54,21 +55,22 @@ describe('FlowModel.getFlows sorting and getEventFlows(beforeRender) order', ()
     const autoFlowKeys = model.getEventFlows('beforeRender').map((f) => f.key);
 
     // auto flows should exclude event/manual flows
-    expect(autoFlowKeys).toEqual(['flowD', 'flowB', 'flowC', 'flowE', 'flowA']);
+    // 新顺序：动态流组（flowD 0, flowC 7, flowE 8）→ 静态流组（flowB 5, flowA 10）
+    expect(autoFlowKeys).toEqual(['flowD', 'flowC', 'flowE', 'flowB', 'flowA']);
 
     // relative order should match getFlows order (subset in same sequence)
     const filteredGetFlowsOrder = getFlowsOrder.filter((k) => !['eventFlow', 'manualFlow'].includes(k));
     expect(autoFlowKeys).toEqual(filteredGetFlowsOrder);
   });
 
-  test('getFlows tie-breaker: static before instance when sort equal', () => {
+  test('getFlows tie-breaker: instance before static when sort equal', () => {
     // static flow with sort 2
     TestFlowModel.registerFlow('static2', { title: 'S2', sort: 2, steps: {} });
     // instance flow with same sort 2
     model.registerFlow('instance2', { title: 'I2', sort: 2, steps: {} });
 
     const keys = Array.from(model.getFlows().keys());
-    expect(keys.indexOf('static2')).toBeLessThan(keys.indexOf('instance2'));
+    expect(keys.indexOf('instance2')).toBeLessThan(keys.indexOf('static2'));
   });
 
   test('getFlows tie-breaker: parent static before child static when sort equal', () => {
@@ -97,4 +99,26 @@ describe('FlowModel.getFlows sorting and getEventFlows(beforeRender) order', ()
     const keys = Array.from(staticFlows.keys());
     expect(keys.indexOf('p')).toBeLessThan(keys.indexOf('c'));
   });
+
+  test('instance flows keep registration order when sort equal', () => {
+    // same sort for all instance flows -> keep registration order
+    model.registerFlow('i1', { title: 'I1', sort: 1, steps: {} } as any);
+    model.registerFlow('i2', { title: 'I2', sort: 1, steps: {} } as any);
+    model.registerFlow('i3', { title: 'I3', sort: 1, steps: {} } as any);
+
+    // add some static flows to ensure grouping doesn't affect instance intra-order
+    (TestFlowModel as any).registerFlow('s1', { title: 'S1', sort: 1, steps: {} });
+    (TestFlowModel as any).registerFlow('s2', { title: 'S2', sort: 2, steps: {} });
+
+    const keys = Array.from(model.getFlows().keys());
+    // Instance group appears first and preserves registration order
+    const posI1 = keys.indexOf('i1');
+    const posI2 = keys.indexOf('i2');
+    const posI3 = keys.indexOf('i3');
+    expect(posI1).toBeLessThan(posI2);
+    expect(posI2).toBeLessThan(posI3);
+
+    // Static group follows
+    expect(keys.slice(posI3 + 1)).toEqual(expect.arrayContaining(['s1', 's2']));
+  });
 });

package/src/models/__tests__/flowModel.test.ts

@@ -898,7 +898,7 @@ describe('FlowModel', () => {
           expect(_dispatchEventSpy).toHaveBeenCalledWith(
             'normalEvent',
             { data: 'test' },
-            expect.objectContaining({ sequential: undefined }),
+            expect.objectContaining({ sequential: true }),
           );
           expect(_dispatchEventWithDebounceSpy).not.toHaveBeenCalled();
 
@@ -919,7 +919,7 @@ describe('FlowModel', () => {
           expect(_dispatchEventSpy).toHaveBeenCalledWith(
             'defaultEvent',
             { data: 'test' },
-            expect.objectContaining({ sequential: undefined }),
+            expect.objectContaining({ sequential: true }),
           );
           expect(_dispatchEventWithDebounceSpy).not.toHaveBeenCalled();
 
@@ -940,7 +940,7 @@ describe('FlowModel', () => {
           expect(_dispatchEventSpy).toHaveBeenCalledWith(
             'undefinedOptionsEvent',
             { data: 'test' },
-            expect.objectContaining({ sequential: undefined }),
+            expect.objectContaining({ sequential: true }),
           );
           expect(_dispatchEventWithDebounceSpy).not.toHaveBeenCalled();
 

package/src/models/flowModel.tsx

@@ -611,17 +611,22 @@ export class FlowModel<Structure extends DefaultStructure = DefaultStructure> {
     const instanceKeys = new Set(instanceFlows.keys());
     const staticEntries = Array.from(staticFlows.entries()).filter(([key]) => !instanceKeys.has(key));
 
-    // 实例流保持原始注册顺序，统一一次排序（稳定排序）：
+    // 组内排序：
+    // - 静态流：GlobalFlowRegistry 已按 sort 和继承深度排序，直接使用
+    // - 实例流：按 sort 升序；相同 sort 保持注册顺序
     const instanceEntries = Array.from(instanceFlows.entries());
-    const allEntries = [...staticEntries, ...instanceEntries];
-    allEntries.sort(([, a], [, b]) => {
-      const sa = a.sort ?? 0;
-      const sb = b.sort ?? 0;
+    const instanceEntriesWithIndex = instanceEntries.map((e, i) => ({ e, i }));
+    instanceEntriesWithIndex.sort((a, b) => {
+      const sa = a.e[1].sort ?? 0;
+      const sb = b.e[1].sort ?? 0;
       if (sa !== sb) return sa - sb;
-      return 0; // 其它情况保持稳定顺序（静态内部：父类优先；实例内部：注册顺序）
+      return a.i - b.i; // 稳定顺序
     });
 
-    return new Map<string, FlowDefinition>(allEntries);
+    // 分组合并：动态流（实例）优先于静态流
+    const merged: [string, FlowDefinition][] = [...instanceEntriesWithIndex.map(({ e }) => e), ...staticEntries];
+
+    return new Map<string, FlowDefinition>(merged);
   }
 
   setProps(props: IModelComponentProps): void;
@@ -733,8 +738,8 @@ export class FlowModel<Structure extends DefaultStructure = DefaultStructure> {
     } & DispatchEventOptions,
   ): Promise<any[]> {
     const isBeforeRender = eventName === 'beforeRender';
-    // 缺省值由模型层提供：beforeRender 默认顺序执行 + 使用缓存；可被 options 覆盖
-    const defaults = isBeforeRender ? { sequential: true, useCache: true } : {};
+    // 缺省值由模型层提供：beforeRender 默认顺序执行 + 使用缓存；其它事件默认顺序执行（不默认使用缓存）
+    const defaults = isBeforeRender ? { sequential: true, useCache: true } : { sequential: true };
     const execOptions = {
       sequential: options?.sequential ?? (defaults as any).sequential,
       useCache: options?.useCache ?? (defaults as any).useCache,

package/src/utils/__tests__/flows.test.ts

@@ -0,0 +1,65 @@
+/**
+ * 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 { describe, test, expect } from 'vitest';
+import { FlowEngine } from '../../flowEngine';
+import { FlowModel } from '../../models/flowModel';
+import { isBeforeRenderFlow } from '../index';
+
+describe('utils/isBeforeRenderFlow', () => {
+  test('identifies beforeRender by on string', () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+    const m = engine.createModel({ use: 'M' });
+    m.registerFlow('A', { on: 'beforeRender', steps: {} });
+    const flow = m.flowRegistry.getFlow('A')!;
+    expect(isBeforeRenderFlow(flow)).toBe(true);
+  });
+
+  test('identifies beforeRender by on object', () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+    const m = engine.createModel({ use: 'M' });
+    m.registerFlow('B', { on: { eventName: 'beforeRender' }, steps: {} });
+    const flow = m.flowRegistry.getFlow('B')!;
+    expect(isBeforeRenderFlow(flow)).toBe(true);
+  });
+
+  test('treats missing on and non-manual as beforeRender', () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+    const m = engine.createModel({ use: 'M' });
+    m.registerFlow('C', { steps: {} });
+    const flow = m.flowRegistry.getFlow('C')!;
+    expect(isBeforeRenderFlow(flow)).toBe(true);
+  });
+
+  test('manual flow is not beforeRender when on is missing', () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+    const m = engine.createModel({ use: 'M' });
+    m.registerFlow('D', { manual: true, steps: {} });
+    const flow = m.flowRegistry.getFlow('D')!;
+    expect(isBeforeRenderFlow(flow)).toBe(false);
+  });
+
+  test('non-beforeRender event is not beforeRender', () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+    const m = engine.createModel({ use: 'M' });
+    m.registerFlow('E', { on: { eventName: 'click' }, steps: {} });
+    const flow = m.flowRegistry.getFlow('E')!;
+    expect(isBeforeRenderFlow(flow)).toBe(false);
+  });
+});

package/src/utils/flows.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 { FlowDefinition } from '../FlowDefinition';
+
+export const isBeforeRenderFlow = (flow: FlowDefinition): boolean => {
+  if (typeof flow.on === 'string') {
+    return flow.on === 'beforeRender';
+  }
+  if (typeof flow.on === 'object') {
+    return flow.on.eventName === 'beforeRender';
+  }
+  if (!flow.on && flow.manual !== true) {
+    return true;
+  }
+  return false;
+};

package/src/utils/index.ts

@@ -63,5 +63,9 @@ export { buildSettingsViewInputArgs } from './buildSettingsViewInputArgs';
 // 安全全局对象（window/document）
 export { createSafeDocument, createSafeWindow, createSafeNavigator } from './safeGlobals';
 
+// Ephemeral context helper（用于临时注入属性/方法，避免污染父级 ctx）
+export { createEphemeralContext } from './createEphemeralContext';
+
 // Filter helpers
 export { pruneFilter } from './pruneFilter';
+export { isBeforeRenderFlow } from './flows';