@nocobase/flow-engine 2.0.0-alpha.4 → 2.0.0-alpha.41

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

@@ -10,19 +10,19 @@
 import { describe, expect, test, beforeEach } from 'vitest';
 import { FlowModel } from '@nocobase/flow-engine';
 
-describe('FlowModel.getFlows sorting and getAutoFlows order', () => {
+describe('FlowModel.getFlows sorting and getEventFlows(beforeRender) order', () => {
   let TestFlowModel: typeof FlowModel;
   let model: FlowModel;
 
   beforeEach(() => {
     // use a fresh subclass to isolate class-level registries
-    TestFlowModel = class extends FlowModel {};
+    TestFlowModel = class extends FlowModel<any> {};
     // provide a minimal fake engine to avoid circular deps in tests
     const fakeEngine = { getModel: () => undefined } as any;
     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,10 +34,11 @@ describe('FlowModel.getFlows sorting and getAutoFlows 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('getAutoFlows keeps getFlows order and filters out manual/on flows', () => {
+  test("getEventFlows('beforeRender') keeps getFlows order and filters out manual/on flows", () => {
     // class-level
     TestFlowModel.registerFlow('flowA', { title: 'A', sort: 10, steps: {} });
     TestFlowModel.registerFlow('flowB', { title: 'B', sort: 5, steps: {} });
@@ -51,24 +52,25 @@ describe('FlowModel.getFlows sorting and getAutoFlows order', () => {
     model.registerFlow('manualFlow', { title: 'Manual', manual: true, sort: -1, steps: {} });
 
     const getFlowsOrder = Array.from(model.getFlows().keys());
-    const autoFlowKeys = model.getAutoFlows().map((f) => f.key);
+    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 getAutoFlows 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.scheduleModelOperation.test.tsx

@@ -0,0 +1,129 @@
+/**
+ * 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, it, expect, vi } from 'vitest';
+import { act } from 'react-dom/test-utils';
+import { FlowEngine, FlowModel } from '../..';
+
+function newEngine(): FlowEngine {
+  const engine = new FlowEngine();
+  // 提供最小 api，避免 ctx.auth getter 在测试输出时抛错
+  engine.context.defineProperty('api', { value: { auth: { role: 'guest', locale: 'zh-CN', token: '' } } });
+  return engine;
+}
+
+describe('FlowModel scheduleModelOperation cross-model (target not created yet)', () => {
+  it('should apply modification when target is created (when: created)', async () => {
+    const engine = newEngine();
+    const from = engine.createModel<FlowModel>({ use: 'FlowModel', uid: 'from-created-1' });
+    const targetUid = 'to-created-1';
+
+    engine.scheduleModelOperation(
+      from,
+      targetUid,
+      async (m) => {
+        m.setProps('foo', 'bar');
+      },
+      { when: 'created' },
+    );
+
+    // 尚未创建目标，先验证未执行
+    expect(engine.getModel(targetUid)).toBeUndefined();
+
+    // 创建目标模型，触发 created 事件
+    const to = engine.createModel<FlowModel>({ use: 'FlowModel', uid: targetUid });
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(to.getProps().foo).toBe('bar');
+  });
+
+  it('should apply modification when target is mounted (when: mounted)', async () => {
+    const engine = newEngine();
+    const from = engine.createModel<FlowModel>({ use: 'FlowModel', uid: 'from-mounted-1' });
+    const targetUid = 'to-mounted-1';
+
+    engine.scheduleModelOperation(
+      from,
+      targetUid,
+      async (m) => {
+        m.setProps('mountedMark', true);
+      },
+      { when: 'mounted' },
+    );
+
+    const to = engine.createModel<FlowModel>({ use: 'FlowModel', uid: targetUid });
+    const root = engine.reactView.createRoot(document.createElement('div'));
+    await act(async () => {
+      root.render(to.render());
+    });
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(to.getProps().mountedMark).toBe(true);
+    root.unmount();
+  });
+
+  it("should apply modification when beforeRender ends (when: 'event:beforeRender:end')", async () => {
+    const engine = newEngine();
+    const from = engine.createModel<FlowModel>({ use: 'FlowModel', uid: 'from-ready-1' });
+    const targetUid = 'to-ready-1';
+
+    engine.scheduleModelOperation(
+      from,
+      targetUid,
+      async (m) => {
+        m.setProps('readyMark', 'done');
+      },
+      { when: 'event:beforeRender:end' },
+    );
+
+    const to = engine.createModel<FlowModel>({ use: 'FlowModel', uid: targetUid });
+    // 触发 beforeRender 完成
+    await engine.executor.dispatchEvent(to, 'beforeRender');
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(to.getProps().readyMark).toBe('done');
+  });
+
+  it("model.scheduleModelOperation proxies engine and runs on 'event:beforeRender:end'", async () => {
+    const engine = newEngine();
+    const from = engine.createModel<FlowModel>({ use: 'FlowModel', uid: 'from-model-proxy-1' });
+    const to = engine.createModel<FlowModel>({ use: 'FlowModel', uid: 'to-model-proxy-1' });
+
+    const fn = vi.fn();
+    from.scheduleModelOperation(to.uid, fn, { when: 'event:beforeRender:end' });
+    await engine.executor.dispatchEvent(to, 'beforeRender');
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  it("model.scheduleModelOperation triggers immediately on 'created' when target exists", async () => {
+    const engine = newEngine();
+    const target = engine.createModel<FlowModel>({ use: 'FlowModel', uid: 'to-model-proxy-created' });
+    const from = engine.createModel<FlowModel>({ use: 'FlowModel', uid: 'from-model-proxy-created' });
+
+    const fn = vi.fn();
+    from.scheduleModelOperation(target.uid, fn, { when: 'created' });
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  it('model.scheduleModelOperation delegates to engine.scheduleModelOperation', async () => {
+    const engine = newEngine();
+    const from = engine.createModel<FlowModel>({ use: 'FlowModel', uid: 'from-model-proxy-delegate' });
+    const to = engine.createModel<FlowModel>({ use: 'FlowModel', uid: 'to-model-proxy-delegate' });
+    const cb = vi.fn();
+    const spy = vi.spyOn(engine, 'scheduleModelOperation');
+
+    from.scheduleModelOperation(to.uid, cb, { when: 'created' });
+
+    expect(spy).toHaveBeenCalledTimes(1);
+    const [argFrom, argUid, argFn, argOptions] = (spy as any).mock.calls[0];
+    expect(argFrom).toBe(from);
+    expect(argUid).toBe(to.uid);
+    expect(argFn).toBe(cb);
+    expect(argOptions).toEqual({ when: 'created' });
+  });
+});