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

package/src/__tests__/flowEngine.dataSourceDirty.test.ts

@@ -0,0 +1,63 @@
+/**
+ * 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, expect, it, vi } from 'vitest';
+import { FlowEngine } from '../flowEngine';
+import { MultiRecordResource } from '../resources/multiRecordResource';
+import { SingleRecordResource } from '../resources/singleRecordResource';
+
+describe('FlowEngine dataSource dirty registry', () => {
+  it('tracks versions per dataSourceKey + resourceName', () => {
+    const engine = new FlowEngine();
+
+    expect(engine.getDataSourceDirtyVersion('main', 'posts')).toBe(0);
+    expect(engine.markDataSourceDirty('main', 'posts')).toBe(1);
+    expect(engine.getDataSourceDirtyVersion('main', 'posts')).toBe(1);
+
+    expect(engine.markDataSourceDirty('main', 'posts')).toBe(2);
+    expect(engine.getDataSourceDirtyVersion('main', 'posts')).toBe(2);
+
+    // different resource
+    expect(engine.getDataSourceDirtyVersion('main', 'users')).toBe(0);
+    expect(engine.markDataSourceDirty('main', 'users')).toBe(1);
+    expect(engine.getDataSourceDirtyVersion('main', 'users')).toBe(1);
+
+    // different data source
+    expect(engine.getDataSourceDirtyVersion('ds2', 'posts')).toBe(0);
+    expect(engine.markDataSourceDirty('ds2', 'posts')).toBe(1);
+    expect(engine.getDataSourceDirtyVersion('ds2', 'posts')).toBe(1);
+    // main unchanged
+    expect(engine.getDataSourceDirtyVersion('main', 'posts')).toBe(2);
+  });
+
+  it('marks dirty on record write operations (single & multi)', async () => {
+    const engine = new FlowEngine();
+    const markSpy = vi.spyOn(engine, 'markDataSourceDirty');
+
+    const single = engine.createResource(SingleRecordResource);
+    single.setDataSourceKey('main');
+    single.setResourceName('posts');
+    // avoid network: stub runAction + refresh
+    (single as any).runAction = vi.fn().mockResolvedValue({ data: {}, meta: {} });
+    (single as any).refresh = vi.fn().mockResolvedValue(undefined);
+    await single.save({ title: 't' } as any, { refresh: false });
+    expect(markSpy).toHaveBeenCalledWith('main', 'posts');
+
+    const multi = engine.createResource(MultiRecordResource);
+    multi.setDataSourceKey('main');
+    multi.setResourceName('users.profile');
+    (multi as any).runAction = vi.fn().mockResolvedValue({ data: [], meta: {} });
+    (multi as any).refresh = vi.fn().mockResolvedValue(undefined);
+    await multi.create({ name: 'n' } as any, { refresh: false });
+    // exact association
+    expect(markSpy).toHaveBeenCalledWith('main', 'users.profile');
+    // plus root collection (safety)
+    expect(markSpy).toHaveBeenCalledWith('main', 'users');
+  });
+});

package/src/__tests__/flowEngine.modelLoaders.test.ts

@@ -0,0 +1,249 @@
+/**
+ * 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 { beforeEach, describe, expect, it, vi } from 'vitest';
+import { FlowEngine } from '../flowEngine';
+import { ErrorFlowModel, FlowModel } from '../models';
+import type { IFlowModelRepository } from '../types';
+
+class MockFlowModelRepository implements IFlowModelRepository {
+  findOneResult: any = null;
+  save = vi.fn(async (model: FlowModel) => ({ success: true, uid: model.uid }));
+
+  async findOne(_query?: any) {
+    return this.findOneResult ? JSON.parse(JSON.stringify(this.findOneResult)) : null;
+  }
+
+  async ensure(options: any) {
+    return await this.findOne(options);
+  }
+
+  async destroy() {
+    return true;
+  }
+
+  async move() {}
+
+  async duplicate() {
+    return null;
+  }
+}
+
+describe('FlowEngine model loaders', () => {
+  let engine: FlowEngine;
+  let repo: MockFlowModelRepository;
+
+  beforeEach(() => {
+    engine = new FlowEngine();
+    repo = new MockFlowModelRepository();
+    engine.setModelRepository(repo);
+  });
+
+  it('resolves explicit and meta-default model trees before synchronous creation', async () => {
+    class ParentModel extends FlowModel {}
+    class ChildModel extends FlowModel {}
+    class DefaultChildModel extends FlowModel {}
+
+    ParentModel.define({
+      createModelOptions: {
+        subModels: {
+          defaultChild: {
+            use: 'DefaultChildModel',
+          },
+        },
+      },
+    });
+
+    const parentLoader = vi.fn(async () => ({ ParentModel }));
+    const childLoader = vi.fn(async () => ({ ChildModel }));
+    const defaultChildLoader = vi.fn(async () => ({ DefaultChildModel }));
+
+    engine.registerModelLoaders({
+      ParentModel: { loader: parentLoader },
+      ChildModel: { loader: childLoader },
+      DefaultChildModel: { loader: defaultChildLoader },
+    });
+
+    const model = await engine.loadOrCreateModel({
+      uid: 'parent-model',
+      use: 'ParentModel',
+      subModels: {
+        child: {
+          use: 'ChildModel',
+        },
+      },
+    });
+
+    expect(model).toBeInstanceOf(ParentModel);
+    expect(model?.subModels.child).toBeInstanceOf(ChildModel);
+    expect(model?.subModels.defaultChild).toBeInstanceOf(DefaultChildModel);
+    expect(parentLoader).toHaveBeenCalledTimes(1);
+    expect(childLoader).toHaveBeenCalledTimes(1);
+    expect(defaultChildLoader).toHaveBeenCalledTimes(1);
+  });
+
+  it('resolves repository-loaded model trees before loadModel creates instances', async () => {
+    class RepoRootModel extends FlowModel {}
+    class RepoChildModel extends FlowModel {}
+
+    const rootLoader = vi.fn(async () => ({ RepoRootModel }));
+    const childLoader = vi.fn(async () => ({ RepoChildModel }));
+
+    engine.registerModelLoaders({
+      RepoRootModel: { loader: rootLoader },
+      RepoChildModel: { loader: childLoader },
+    });
+
+    repo.findOneResult = {
+      uid: 'repo-root',
+      use: 'RepoRootModel',
+      subModels: {
+        child: {
+          use: 'RepoChildModel',
+        },
+      },
+    };
+
+    const model = await engine.loadModel({ uid: 'repo-root' });
+
+    expect(model).toBeInstanceOf(RepoRootModel);
+    expect(model?.subModels.child).toBeInstanceOf(RepoChildModel);
+    expect(rootLoader).toHaveBeenCalledTimes(1);
+    expect(childLoader).toHaveBeenCalledTimes(1);
+  });
+
+  it('supports async model creation and async getters', async () => {
+    class AsyncRootModel extends FlowModel {}
+    class AsyncChildModel extends FlowModel {}
+
+    const rootLoader = vi.fn(async () => ({ AsyncRootModel }));
+    const childLoader = vi.fn(async () => ({ AsyncChildModel }));
+
+    engine.registerModelLoaders({
+      AsyncRootModel: { loader: rootLoader },
+      AsyncChildModel: { loader: childLoader },
+    });
+
+    const rootClass = await engine.getModelClassAsync('AsyncRootModel');
+    const classes = await engine.getModelClassesAsync();
+    const model = await engine.createModelAsync({
+      uid: 'async-root',
+      use: 'AsyncRootModel',
+      subModels: {
+        child: {
+          use: 'AsyncChildModel',
+        },
+      },
+    });
+
+    expect(rootClass).toBe(AsyncRootModel);
+    expect(classes.get('AsyncRootModel')).toBe(AsyncRootModel);
+    expect(classes.get('AsyncChildModel')).toBe(AsyncChildModel);
+    expect(model).toBeInstanceOf(AsyncRootModel);
+    expect(model.subModels.child).toBeInstanceOf(AsyncChildModel);
+    expect(rootLoader).toHaveBeenCalledTimes(1);
+    expect(childLoader).toHaveBeenCalledTimes(1);
+  });
+
+  it('createModelAsync degrades unresolved loader failures to ErrorFlowModel', async () => {
+    const invalidLoader = vi.fn(async () => ({ notAModel: {} }));
+
+    engine.registerModelLoaders({
+      BrokenRootModel: { loader: invalidLoader as any },
+    });
+
+    const model = await engine.createModelAsync({
+      uid: 'broken-root',
+      use: 'BrokenRootModel',
+    });
+
+    expect(model).toBeInstanceOf(ErrorFlowModel);
+    expect(invalidLoader).toHaveBeenCalledTimes(1);
+  });
+
+  it('keeps loader resolution idempotent across resolveModelTree and flow settings preload', async () => {
+    class RuntimeResolvedModel extends FlowModel {}
+    class DesignResolvedModel extends FlowModel {}
+
+    const runtimeLoader = vi.fn(async () => ({ RuntimeResolvedModel }));
+    const designLoader = vi.fn(async () => ({ DesignResolvedModel }));
+
+    engine.registerModelLoaders({
+      RuntimeResolvedModel: { loader: runtimeLoader },
+      DesignResolvedModel: { loader: designLoader },
+    });
+
+    await engine.resolveModelTree({
+      use: 'RuntimeResolvedModel',
+    });
+
+    const firstPreload = await engine.preloadModelLoaders();
+    const secondPreload = await engine.preloadModelLoaders();
+
+    expect(runtimeLoader).toHaveBeenCalledTimes(1);
+    expect(designLoader).toHaveBeenCalledTimes(1);
+    expect(firstPreload.loaded).toContain('DesignResolvedModel');
+    expect(firstPreload.loaded).not.toContain('RuntimeResolvedModel');
+    expect(secondPreload.loaded).toHaveLength(0);
+    expect(secondPreload.failed).toHaveLength(0);
+  });
+
+  it('picks up newly registered loaders after preload has already completed', async () => {
+    class FirstModel extends FlowModel {}
+    class SecondModel extends FlowModel {}
+
+    const firstLoader = vi.fn(async () => ({ FirstModel }));
+    const secondLoader = vi.fn(async () => ({ SecondModel }));
+
+    engine.registerModelLoaders({
+      FirstModel: { loader: firstLoader },
+    });
+
+    await engine.preloadModelLoaders();
+    expect(firstLoader).toHaveBeenCalledTimes(1);
+    expect(engine.getModelClass('FirstModel')).toBe(FirstModel);
+
+    engine.registerModelLoaders({
+      SecondModel: { loader: secondLoader },
+    });
+
+    const result = await engine.preloadModelLoaders();
+
+    expect(secondLoader).toHaveBeenCalledTimes(1);
+    expect(result.loaded).toContain('SecondModel');
+    expect(engine.getModelClass('SecondModel')).toBe(SecondModel);
+  });
+
+  it('degrades unresolved loader failures to ErrorFlowModel instead of crashing runtime creation', async () => {
+    class ParentModel extends FlowModel {}
+
+    const parentLoader = vi.fn(async () => ({ ParentModel }));
+    const invalidChildLoader = vi.fn(async () => ({ notAModel: {} }));
+
+    engine.registerModelLoaders({
+      ParentModel: { loader: parentLoader },
+      BrokenChildModel: { loader: invalidChildLoader as any },
+    });
+
+    const model = await engine.loadOrCreateModel({
+      uid: 'parent-with-broken-child',
+      use: 'ParentModel',
+      subModels: {
+        child: {
+          use: 'BrokenChildModel',
+        },
+      },
+    });
+
+    expect(model).toBeInstanceOf(ParentModel);
+    expect(model?.subModels.child).toBeInstanceOf(ErrorFlowModel);
+    expect(parentLoader).toHaveBeenCalledTimes(1);
+    expect(invalidChildLoader).toHaveBeenCalledTimes(1);
+  });
+});

package/src/__tests__/flowEngine.saveModel.test.ts

@@ -40,6 +40,10 @@ class MockFlowModelRepository implements IFlowModelRepository {
     return null;
   }
 
+  async ensure(options: any): Promise<any> {
+    return await this.findOne(options);
+  }
+
   async destroy(uid: string): Promise<boolean> {
     return true;
   }

package/src/__tests__/flowModel.openView.navigation.test.ts

@@ -76,4 +76,32 @@ describe('FlowModelContext.openView - navigation enforcement', () => {
     const dispatchedParams = child.dispatchEvent.mock.calls[0][1];
     expect(dispatchedParams.navigation).toBe(false);
   });
+
+  it('dispatches the popupSettings bound event (object form) when opening external popup', async () => {
+    const { parent, child } = setup();
+
+    child.getFlow = vi.fn((key: string) => {
+      if (key !== 'popupSettings') return undefined;
+      return { on: { eventName: 'openDuplicatePopup' } };
+    });
+
+    await (parent.context as any).openView('child-uid', { mode: 'drawer' });
+
+    expect(child.dispatchEvent).toHaveBeenCalledTimes(1);
+    expect(child.dispatchEvent.mock.calls[0][0]).toBe('openDuplicatePopup');
+  });
+
+  it('falls back to click when popupSettings has no explicit on event', async () => {
+    const { parent, child } = setup();
+
+    child.getFlow = vi.fn((key: string) => {
+      if (key !== 'popupSettings') return undefined;
+      return { on: undefined };
+    });
+
+    await (parent.context as any).openView('child-uid', { mode: 'drawer' });
+
+    expect(child.dispatchEvent).toHaveBeenCalledTimes(1);
+    expect(child.dispatchEvent.mock.calls[0][0]).toBe('click');
+  });
 });

package/src/__tests__/flowRunJSContextDefine.test.ts

@@ -61,6 +61,69 @@ describe('FlowRunJSContext.define() and getDoc() deep tests', () => {
       expect(apiProp.properties?.auth?.description).toBe('Auth info');
     });
 
+    it('should treat string doc as description when overriding object docs', () => {
+      class BaseDocContext extends FlowRunJSContext {}
+      class ChildDocContext extends BaseDocContext {}
+
+      BaseDocContext.define({
+        properties: {
+          foo: {
+            description: 'Base foo',
+            detail: 'FooDetail',
+            hidden: true,
+            completion: { insertText: 'ctx.foo' },
+            properties: {
+              bar: { description: 'Bar desc' },
+            },
+          },
+        },
+      });
+
+      ChildDocContext.define({
+        properties: {
+          foo: 'Child foo',
+        },
+      });
+
+      const doc = ChildDocContext.getDoc();
+      const foo: any = doc.properties?.foo;
+      expect(foo).toBeTruthy();
+      expect(typeof foo).toBe('object');
+      expect(foo.description).toBe('Child foo');
+      expect(foo.hidden).toBe(true);
+      expect(foo.detail).toBe('FooDetail');
+      expect(foo.completion?.insertText).toBe('ctx.foo');
+      expect(foo.properties?.bar?.description).toBe('Bar desc');
+    });
+
+    it('should preserve base string description when patch adds object doc', () => {
+      class BaseStringDocContext extends FlowRunJSContext {}
+      class ChildObjectDocContext extends BaseStringDocContext {}
+
+      BaseStringDocContext.define({
+        properties: {
+          foo: 'Base foo',
+        },
+      });
+
+      ChildObjectDocContext.define({
+        properties: {
+          foo: {
+            properties: {
+              bar: 'Bar',
+            },
+          },
+        },
+      });
+
+      const doc = ChildObjectDocContext.getDoc();
+      const foo: any = doc.properties?.foo;
+      expect(foo).toBeTruthy();
+      expect(typeof foo).toBe('object');
+      expect(foo.description).toBe('Base foo');
+      expect(foo.properties?.bar).toBe('Bar');
+    });
+
     it('should deep merge method documentation', () => {
       class MethodMergeContext extends FlowRunJSContext {}
 

package/src/__tests__/flowRuntimeContext.test.ts

@@ -11,6 +11,7 @@ import { ContextPathProxy } from '../ContextPathProxy';
 import { FlowRuntimeContext } from '../flowContext';
 import { FlowEngine } from '../flowEngine';
 import { FlowModel } from '../models/flowModel';
+import { FlowExitAllException } from '../utils/exceptions';
 
 describe('FlowRuntimeContext', () => {
   let engine: FlowEngine;
@@ -46,7 +47,7 @@ describe('FlowRuntimeContext', () => {
 
   it('should throw on exit()', () => {
     const ctx = new FlowRuntimeContext(model, 'flow1', 'runtime');
-    expect(() => ctx.exit()).toThrow();
+    expect(() => ctx.exit()).toThrow(FlowExitAllException);
   });
 });
 

package/src/__tests__/flowSettings.open.test.tsx

@@ -12,6 +12,7 @@ import { screen } from '@testing-library/react';
 import { FlowSettings } from '../flowSettings';
 import { FlowModel } from '../models';
 import { FlowEngine } from '../flowEngine';
+import { GLOBAL_EMBED_CONTAINER_ID } from '../views';
 
 // We will stub viewer directly on model.context in tests
 
@@ -1087,18 +1088,18 @@ describe('FlowSettings.open rendering behavior', () => {
 
     // Create mock DOM element for embed target
     const mockTarget = document.createElement('div');
-    mockTarget.id = 'nocobase-embed-container';
+    mockTarget.id = GLOBAL_EMBED_CONTAINER_ID;
     mockTarget.style.width = 'auto';
     mockTarget.style.maxWidth = 'none';
     document.body.appendChild(mockTarget);
 
     // Mock querySelector to return our mock element
-    const originalQuerySelector = document.querySelector;
-    document.querySelector = vi.fn((selector) => {
-      if (selector === '#nocobase-embed-container') {
+    const originalQuerySelector = document.querySelector.bind(document);
+    const querySelectorSpy = vi.spyOn(document, 'querySelector').mockImplementation((selector: string) => {
+      if (selector === `#${GLOBAL_EMBED_CONTAINER_ID}`) {
         return mockTarget;
       }
-      return originalQuerySelector.call(document, selector);
+      return originalQuerySelector(selector);
     });
 
     const M = model.constructor as any;
@@ -1164,7 +1165,61 @@ describe('FlowSettings.open rendering behavior', () => {
 
     // Cleanup
     document.body.removeChild(mockTarget);
-    document.querySelector = originalQuerySelector;
+    querySelectorSpy.mockRestore();
+  });
+
+  it('does not clear embed target DOM before opening (avoids portal unmount errors)', async () => {
+    const engine = new FlowEngine();
+    const flowSettings = new FlowSettings(engine);
+    const model = new FlowModel({ uid: 'm-embed-no-clear', flowEngine: engine });
+
+    const mockTarget = document.createElement('div');
+    mockTarget.id = GLOBAL_EMBED_CONTAINER_ID;
+    mockTarget.innerHTML = '<div data-testid="existing">Existing</div>';
+    document.body.appendChild(mockTarget);
+
+    const originalQuerySelector = document.querySelector.bind(document);
+    const querySelectorSpy = vi.spyOn(document, 'querySelector').mockImplementation((selector: string) => {
+      if (selector === `#${GLOBAL_EMBED_CONTAINER_ID}`) {
+        return mockTarget;
+      }
+      return originalQuerySelector(selector);
+    });
+
+    const M = model.constructor as any;
+    M.registerFlow({
+      key: 'embedNoClearFlow',
+      steps: {
+        step: {
+          title: 'Step',
+          uiSchema: { f: { type: 'string', 'x-component': 'Input' } },
+        },
+      },
+    });
+
+    const embed = vi.fn((opts: any) => {
+      // The existing DOM should not be wiped out before opening the embed view.
+      expect(mockTarget.querySelector('[data-testid="existing"]')).toBeTruthy();
+      const dlg = { close: vi.fn(), Footer: (p: any) => null } as any;
+      if (typeof opts.content === 'function') opts.content(dlg, { defineMethod: vi.fn() });
+      return dlg;
+    });
+
+    model.context.defineProperty('viewer', { value: { embed } });
+    model.context.defineProperty('message', { value: { info: vi.fn(), error: vi.fn(), success: vi.fn() } });
+
+    await flowSettings.open({
+      model,
+      flowKey: 'embedNoClearFlow',
+      stepKey: 'step',
+      uiMode: 'embed',
+    } as any);
+
+    expect(embed).toHaveBeenCalledTimes(1);
+    expect(mockTarget.querySelector('[data-testid="existing"]')).toBeTruthy();
+
+    document.body.removeChild(mockTarget);
+    querySelectorSpy.mockRestore();
   });
 
   it('uses embed uiMode with default props when target element exists', async () => {
@@ -1174,16 +1229,16 @@ describe('FlowSettings.open rendering behavior', () => {
 
     // Create mock DOM element for embed target
     const mockTarget = document.createElement('div');
-    mockTarget.id = 'nocobase-embed-container';
+    mockTarget.id = GLOBAL_EMBED_CONTAINER_ID;
     document.body.appendChild(mockTarget);
 
     // Mock querySelector
-    const originalQuerySelector = document.querySelector;
-    document.querySelector = vi.fn((selector) => {
-      if (selector === '#nocobase-embed-container') {
+    const originalQuerySelector = document.querySelector.bind(document);
+    const querySelectorSpy = vi.spyOn(document, 'querySelector').mockImplementation((selector: string) => {
+      if (selector === `#${GLOBAL_EMBED_CONTAINER_ID}`) {
         return mockTarget;
       }
-      return originalQuerySelector.call(document, selector);
+      return originalQuerySelector(selector);
     });
 
     const M = model.constructor as any;
@@ -1223,7 +1278,7 @@ describe('FlowSettings.open rendering behavior', () => {
 
     // Cleanup
     document.body.removeChild(mockTarget);
-    document.querySelector = originalQuerySelector;
+    querySelectorSpy.mockRestore();
   });
 
   it('handles embed uiMode when target element is not found', async () => {
@@ -1232,8 +1287,7 @@ describe('FlowSettings.open rendering behavior', () => {
     const model = new FlowModel({ uid: 'm-embed-no-target', flowEngine: engine });
 
     // Mock querySelector to return null (target not found)
-    const originalQuerySelector = document.querySelector;
-    document.querySelector = vi.fn(() => null);
+    const querySelectorSpy = vi.spyOn(document, 'querySelector').mockReturnValue(null);
 
     const M = model.constructor as any;
     M.registerFlow({
@@ -1266,7 +1320,7 @@ describe('FlowSettings.open rendering behavior', () => {
     expect(embed).toHaveBeenCalledTimes(1);
 
     // Restore querySelector
-    document.querySelector = originalQuerySelector;
+    querySelectorSpy.mockRestore();
   });
 
   it('handles error in function-based step uiMode gracefully', async () => {
@@ -1718,8 +1772,8 @@ describe('FlowSettings.open rendering behavior', () => {
     expect(capturedDialog.close).toHaveBeenCalled();
   });
 
-  it('submit method handles FlowExitException by closing dialog without error message', async () => {
-    const { FlowExitException } = await import('../utils/exceptions');
+  it('submit method handles FlowExitAllException by closing dialog without error message', async () => {
+    const { FlowExitAllException } = await import('../utils/exceptions');
 
     const engine = new FlowEngine();
     const flowSettings = new FlowSettings(engine);
@@ -1732,7 +1786,7 @@ describe('FlowSettings.open rendering behavior', () => {
         step: {
           title: 'Step',
           beforeParamsSave: () => {
-            throw new FlowExitException('exitFlow', 'm-submit-exit', 'Exit requested');
+            throw new FlowExitAllException('exitFlow', 'm-submit-exit', 'Exit requested');
           },
           uiSchema: { field: { type: 'string', 'x-component': 'Input' } },
         },
@@ -1764,12 +1818,62 @@ describe('FlowSettings.open rendering behavior', () => {
     // Call submit method
     await capturedDialog.submit();
 
-    // Verify FlowExitException handling
+    // Verify FlowExitAllException handling
     expect(error).not.toHaveBeenCalled(); // Should not show error message
     expect(success).not.toHaveBeenCalled(); // Should not show success message
     expect(capturedDialog.close).toHaveBeenCalled(); // Should close dialog
   });
 
+  it('submit method keeps dialog open on FlowCancelSaveException', async () => {
+    const { FlowCancelSaveException } = await import('../utils/exceptions');
+
+    const engine = new FlowEngine();
+    const flowSettings = new FlowSettings(engine);
+    const TestFlowModel = createIsolatedFlowModel('test-submit-cancel-save');
+    const model = new TestFlowModel({ uid: 'm-submit-cancel-save', flowEngine: engine });
+
+    TestFlowModel.registerFlow({
+      key: 'cancelSaveFlow',
+      steps: {
+        step: {
+          title: 'Step',
+          beforeParamsSave: () => {
+            throw new FlowCancelSaveException();
+          },
+          uiSchema: { field: { type: 'string', 'x-component': 'Input' } },
+        },
+      },
+    });
+
+    const info = vi.fn();
+    const error = vi.fn();
+    const success = vi.fn();
+    model.context.defineProperty('message', { value: { info, error, success } });
+
+    const saveStepParams = vi.spyOn(model as any, 'saveStepParams').mockResolvedValue(undefined);
+
+    let capturedDialog: any;
+    model.context.defineProperty('viewer', {
+      value: {
+        dialog: ({ content }) => {
+          capturedDialog = { close: vi.fn(), Footer: (p: any) => null };
+          if (typeof content === 'function') {
+            content(capturedDialog, { defineMethod: vi.fn() });
+          }
+          return capturedDialog;
+        },
+      },
+    });
+
+    await flowSettings.open({ model, flowKey: 'cancelSaveFlow', stepKey: 'step' } as any);
+    await capturedDialog.submit();
+
+    expect(capturedDialog.close).not.toHaveBeenCalled();
+    expect(saveStepParams).not.toHaveBeenCalled();
+    expect(error).not.toHaveBeenCalled();
+    expect(success).not.toHaveBeenCalled();
+  });
+
   it('submit method handles general errors by showing error message and keeping dialog open', async () => {
     const engine = new FlowEngine();
     const flowSettings = new FlowSettings(engine);