@nocobase/flow-engine 2.1.0-alpha.4 → 2.1.0-alpha.40

package/src/lazy-helper.tsx

@@ -0,0 +1,57 @@
+/**
+ * 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 React, { lazy as reactLazy } from 'react';
+
+type LazyComponentType<M extends Record<string, any>, K extends keyof M> = {
+  [P in K]: M[P];
+};
+
+export function lazy<M extends Record<'default', any>>(factory: () => Promise<M>): M['default'];
+
+export function lazy<M extends Record<string, any>, K extends keyof M = keyof M>(
+  factory: () => Promise<M>,
+  ...componentNames: K[]
+): LazyComponentType<M, K>;
+
+export function lazy<M extends Record<string, any>, K extends keyof M>(
+  factory: () => Promise<M>,
+  ...componentNames: K[]
+) {
+  if (componentNames.length === 0) {
+    const LazyComponent = reactLazy(() =>
+      factory().then((module) => ({
+        default: module.default,
+      })),
+    );
+    const Component = (props) => (
+      <React.Suspense fallback={null}>
+        <LazyComponent {...props} />
+      </React.Suspense>
+    );
+    return Component;
+  }
+
+  return componentNames.reduce(
+    (acc, name) => {
+      const LazyComponent = reactLazy(() =>
+        factory().then((module) => ({
+          default: module[name],
+        })),
+      );
+      acc[name] = ((props) => (
+        <React.Suspense fallback={null}>
+          <LazyComponent {...props} />
+        </React.Suspense>
+      )) as M[K];
+      return acc;
+    },
+    {} as LazyComponentType<M, K>,
+  );
+}

package/src/locale/en-US.json

@@ -34,6 +34,7 @@
   "Failed to destroy model after creation error": "Failed to destroy model after creation error",
   "Failed to get action {{action}}": "Failed to get action {{action}}",
   "Failed to get configurable flows for model {{model}}": "Failed to get configurable flows for model {{model}}",
+  "Attributes are unavailable before selecting a record": "Attributes are unavailable before selecting a record",
   "Failed to import FormDialog": "Failed to import FormDialog",
   "Failed to import FormDialog or FormStep": "Failed to import FormDialog or FormStep",
   "Failed to import Formily components": "Failed to import Formily components",

package/src/locale/zh-CN.json

@@ -31,6 +31,7 @@
   "Failed to destroy model after creation error": "创建错误后销毁模型失败",
   "Failed to get action {{action}}": "获取 action '{{action}}' 失败",
   "Failed to get configurable flows for model {{model}}": "获取模型 '{{model}}' 的可配置 flows 失败",
+  "Attributes are unavailable before selecting a record": "选择记录之前，当前项属性不可用",
   "Failed to import FormDialog": "导入 FormDialog 失败",
   "Failed to import FormDialog or FormStep": "导入 FormDialog 或 FormStep 失败",
   "Failed to import Formily components": "导入 Formily 组件失败",

package/src/models/DisplayItemModel.tsx

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { DefaultStructure } from '@nocobase/flow-engine';
+import type { DefaultStructure } from '../types';
 import { CollectionFieldModel } from './CollectionFieldModel';
 
 export class DisplayItemModel<T extends DefaultStructure = DefaultStructure> extends CollectionFieldModel<T> {}

package/src/models/EditableItemModel.tsx

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { DefaultStructure } from '@nocobase/flow-engine';
+import type { DefaultStructure } from '../types';
 import { CollectionFieldModel } from './CollectionFieldModel';
 
 export class EditableItemModel<T extends DefaultStructure = DefaultStructure> extends CollectionFieldModel<T> {}

package/src/models/FilterableItemModel.tsx

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { DefaultStructure } from '@nocobase/flow-engine';
+import type { DefaultStructure } from '../types';
 import { CollectionFieldModel } from './CollectionFieldModel';
 
 export class FilterableItemModel<T extends DefaultStructure = DefaultStructure> extends CollectionFieldModel<T> {}

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

@@ -105,6 +105,45 @@ describe('dispatchEvent dynamic event flow phase (scheduleModelOperation integra
     expect(calls).toEqual(['static-a', 'dynamic']);
   });
 
+  test("phase='afterAllFlows': skips when event aborted by ctx.exitAll()", async () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+
+    const calls: string[] = [];
+
+    M.registerFlow({
+      key: 'S',
+      on: { eventName: 'go' },
+      steps: {
+        a: { handler: async () => void calls.push('static-a') } as any,
+      },
+    });
+
+    const model = engine.createModel({ use: 'M' });
+    model.registerFlow('Abort', {
+      on: { eventName: 'go' },
+      sort: -10,
+      steps: {
+        d: {
+          handler: async (ctx: any) => {
+            calls.push('abort');
+            ctx.exitAll();
+          },
+        } as any,
+      },
+    });
+    model.registerFlow('AfterAll', {
+      on: { eventName: 'go', phase: 'afterAllFlows' },
+      steps: {
+        d: { handler: async () => void calls.push('after-all') } as any,
+      },
+    });
+
+    await model.dispatchEvent('go');
+    expect(calls).toEqual(['abort']);
+  });
+
   test("phase='beforeFlow': instance flow runs before the target static flow", async () => {
     const engine = new FlowEngine();
     class M extends FlowModel {}
@@ -161,6 +200,39 @@ describe('dispatchEvent dynamic event flow phase (scheduleModelOperation integra
     expect(calls).toEqual(['static-a', 'static-b', 'dynamic']);
   });
 
+  test("phase='afterFlow': skips when anchor flow is aborted by ctx.exitAll()", async () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+
+    const calls: string[] = [];
+
+    M.registerFlow({
+      key: 'S',
+      on: { eventName: 'go' },
+      steps: {
+        a: {
+          handler: async (ctx: any) => {
+            calls.push('static-a');
+            ctx.exitAll();
+          },
+        } as any,
+        b: { handler: async () => void calls.push('static-b') } as any,
+      },
+    });
+
+    const model = engine.createModel({ use: 'M' });
+    model.registerFlow('D', {
+      on: { eventName: 'go', phase: 'afterFlow', flowKey: 'S' },
+      steps: {
+        d: { handler: async () => void calls.push('dynamic') } as any,
+      },
+    });
+
+    await model.dispatchEvent('go');
+    expect(calls).toEqual(['static-a']);
+  });
+
   test("phase='beforeStep': instance flow runs before the target static step", async () => {
     const engine = new FlowEngine();
     class M extends FlowModel {}
@@ -217,6 +289,39 @@ describe('dispatchEvent dynamic event flow phase (scheduleModelOperation integra
     expect(calls).toEqual(['static-a', 'dynamic', 'static-b']);
   });
 
+  test("phase='afterStep': skips when anchor step is aborted by ctx.exitAll()", async () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+
+    const calls: string[] = [];
+
+    M.registerFlow({
+      key: 'S',
+      on: { eventName: 'go' },
+      steps: {
+        a: {
+          handler: async (ctx: any) => {
+            calls.push('static-a');
+            ctx.exitAll();
+          },
+        } as any,
+        b: { handler: async () => void calls.push('static-b') } as any,
+      },
+    });
+
+    const model = engine.createModel({ use: 'M' });
+    model.registerFlow('D', {
+      on: { eventName: 'go', phase: 'afterStep', flowKey: 'S', stepKey: 'a' },
+      steps: {
+        d: { handler: async () => void calls.push('dynamic') } as any,
+      },
+    });
+
+    await model.dispatchEvent('go');
+    expect(calls).toEqual(['static-a']);
+  });
+
   test("phase='beforeFlow': ctx.exitAll() stops anchor flow and subsequent flows", async () => {
     const engine = new FlowEngine();
     class M extends FlowModel {}
@@ -430,6 +535,115 @@ describe('dispatchEvent dynamic event flow phase (scheduleModelOperation integra
     expect(calls).toEqual(['static-a', 'dynamic']);
   });
 
+  test('fallback to event:end (missing anchor) skips when event aborted by ctx.exitAll()', async () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+
+    const calls: string[] = [];
+
+    M.registerFlow({
+      key: 'S',
+      on: { eventName: 'go' },
+      steps: {
+        a: { handler: async () => void calls.push('static-a') } as any,
+      },
+    });
+
+    const model = engine.createModel({ use: 'M' });
+    model.registerFlow('Abort', {
+      on: { eventName: 'go' },
+      sort: -10,
+      steps: {
+        d: {
+          handler: async (ctx: any) => {
+            calls.push('abort');
+            ctx.exitAll();
+          },
+        } as any,
+      },
+    });
+    model.registerFlow('FallbackToEnd', {
+      on: { eventName: 'go', phase: 'beforeFlow', flowKey: 'missing' },
+      steps: {
+        d: { handler: async () => void calls.push('fallback-end') } as any,
+      },
+    });
+
+    await model.dispatchEvent('go');
+    expect(calls).toEqual(['abort']);
+  });
+
+  test('event:end is still emitted with aborted=true when exitAll happens', async () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+
+    const endEvents: any[] = [];
+    const onEnd = (payload: any) => {
+      endEvents.push(payload);
+    };
+    engine.emitter.on('model:event:go:end', onEnd);
+
+    const model = engine.createModel({ use: 'M' });
+    model.registerFlow('Abort', {
+      on: { eventName: 'go' },
+      steps: {
+        d: {
+          handler: async (ctx: any) => {
+            ctx.exitAll();
+          },
+        } as any,
+      },
+    });
+
+    await model.dispatchEvent('go');
+    engine.emitter.off('model:event:go:end', onEnd);
+
+    expect(endEvents).toHaveLength(1);
+    expect(endEvents[0]?.aborted).toBe(true);
+  });
+
+  test('flow:end/step:end are emitted with aborted=true when exitAll happens', async () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+
+    const flowEndEvents: any[] = [];
+    const stepEndEvents: any[] = [];
+    const onFlowEnd = (payload: any) => {
+      flowEndEvents.push(payload);
+    };
+    const onStepEnd = (payload: any) => {
+      stepEndEvents.push(payload);
+    };
+    engine.emitter.on('model:event:go:flow:S:end', onFlowEnd);
+    engine.emitter.on('model:event:go:flow:S:step:a:end', onStepEnd);
+
+    M.registerFlow({
+      key: 'S',
+      on: { eventName: 'go' },
+      steps: {
+        a: {
+          handler: async (ctx: any) => {
+            ctx.exitAll();
+          },
+        } as any,
+      },
+    });
+
+    const model = engine.createModel({ use: 'M' });
+    await model.dispatchEvent('go');
+
+    engine.emitter.off('model:event:go:flow:S:end', onFlowEnd);
+    engine.emitter.off('model:event:go:flow:S:step:a:end', onStepEnd);
+
+    expect(flowEndEvents).toHaveLength(1);
+    expect(stepEndEvents).toHaveLength(1);
+    expect(flowEndEvents[0]?.aborted).toBe(true);
+    expect(stepEndEvents[0]?.aborted).toBe(true);
+  });
+
   test('multiple flows on same anchor: executes by flow.sort asc (stable)', async () => {
     const engine = new FlowEngine();
     class M extends FlowModel {}

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

@@ -546,6 +546,34 @@ describe('FlowModel', () => {
 
         loggerSpy.mockRestore();
       });
+
+      test('should warn and skip step when use and handler are both missing', async () => {
+        const warnSpy = vi.spyOn(model.context.logger, 'warn').mockImplementation(() => {});
+        const errorSpy = vi.spyOn(model.context.logger, 'error').mockImplementation(() => {});
+
+        TestFlowModel.registerFlow({
+          key: 'settingsOnlyFlow',
+          steps: {
+            edit: {
+              title: 'Edit',
+              uiSchema: {},
+            },
+          },
+        });
+
+        const result = await model.applyFlow('settingsOnlyFlow');
+
+        expect(result).toEqual({});
+        expect(warnSpy).toHaveBeenCalledWith(
+          expect.stringContaining("Step 'edit' in flow 'settingsOnlyFlow' has neither 'use' nor 'handler'"),
+        );
+        expect(errorSpy).not.toHaveBeenCalledWith(
+          expect.stringContaining("Step 'edit' in flow 'settingsOnlyFlow' has neither 'use' nor 'handler'"),
+        );
+
+        warnSpy.mockRestore();
+        errorSpy.mockRestore();
+      });
     });
 
     describe('beforeRender flows', () => {
@@ -1855,7 +1883,7 @@ describe('FlowModel', () => {
     });
 
     describe('serialization', () => {
-      test('should serialize basic model data, excluding props and flowEngine', () => {
+      test('should serialize basic model data with the latest props, excluding flowEngine', () => {
         model.sortIndex = 5;
         model.setProps({ name: 'Test Model', value: 42 });
         model.setStepParams({
@@ -1867,13 +1895,12 @@ describe('FlowModel', () => {
         expect(serialized).toEqual(
           expect.objectContaining({
             uid: model.uid,
+            props: expect.objectContaining({ name: 'Test Model', value: 42 }),
             stepParams: expect.objectContaining({ flow1: { step1: { param1: 'value1' } } }),
             sortIndex: 5,
             subModels: expect.any(Object),
           }),
         );
-        // props should be excluded from serialization
-        expect(serialized.props).toBeUndefined();
         expect(serialized.flowEngine).toBeUndefined();
       });
 
@@ -1892,6 +1919,7 @@ describe('FlowModel', () => {
         expect(serialized).toEqual(
           expect.objectContaining({
             uid: 'empty-model',
+            props: expect.objectContaining({ foo: 'bar' }),
             stepParams: expect.any(Object),
             sortIndex: expect.any(Number),
             subModels: expect.any(Object),
@@ -1899,6 +1927,22 @@ describe('FlowModel', () => {
         );
         expect(serialized.flowEngine).toBeUndefined();
       });
+
+      test('should serialize the latest props after multiple updates', () => {
+        model.setProps({ fieldNames: { title: 'name' }, searchable: true });
+        model.setProps({ fieldNames: { title: 'age' } });
+        model.setProps('defaultExpandAll', false);
+
+        const serialized = model.serialize();
+
+        expect(serialized.props).toEqual(
+          expect.objectContaining({
+            fieldNames: { title: 'age' },
+            searchable: true,
+            defaultExpandAll: false,
+          }),
+        );
+      });
     });
   });