@nocobase/client-v2 2.2.0-beta.7 → 2.2.0-beta.9

package/src/flow/__tests__/FlowRoute.test.tsx

@@ -9,11 +9,12 @@
 
 import React from 'react';
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { MemoryRouter, Route, Routes } from 'react-router-dom';
-import { render, screen, waitFor } from '@testing-library/react';
+import { MemoryRouter, Route, Router, Routes, useNavigate } from 'react-router-dom';
+import { act, render, screen, waitFor } from '@testing-library/react';
 import { FlowContextProvider, FlowEngine, FlowEngineProvider, type FlowModel } from '@nocobase/flow-engine';
 import FlowRoute from '../components/FlowRoute';
 import { RouteRepository } from '../../RouteRepository';
+import { NocoBaseDesktopRouteType } from '../../flow-compat';
 
 type MockAdminLayoutModel = FlowModel & {
   registerRoutePage: ReturnType<typeof vi.fn>;
@@ -21,6 +22,8 @@ type MockAdminLayoutModel = FlowModel & {
   unregisterRoutePage: ReturnType<typeof vi.fn>;
 };
 
+type RouterNavigator = React.ComponentProps<typeof Router>['navigator'];
+
 const { hookState } = vi.hoisted(() => {
   return {
     hookState: {
@@ -893,6 +896,548 @@ describe('FlowRoute', () => {
     expect(adminLayoutModel.registerRoutePage).not.toHaveBeenCalled();
   });
 
+  it('should render blank content when current admin route matches an accessible empty group id', async () => {
+    const engine = new FlowEngine();
+    const listAccessible = vi.fn(() => [
+      {
+        id: 371750686228480,
+        schemaUid: 'group-schema',
+        title: '789',
+        type: NocoBaseDesktopRouteType.group,
+      },
+    ]);
+    engine.context.defineProperty('routeRepository', {
+      value: {
+        refreshAccessible: hookState.refresh,
+        isAccessibleLoaded: () => true,
+        ensureAccessibleLoaded: vi.fn().mockResolvedValue([]),
+        getRouteBySchemaUid: vi.fn(() => undefined),
+        listAccessible,
+      },
+    });
+    engine.context.defineProperty('app', {
+      value: {
+        getPublicPath: () => '/v2/',
+        router: {
+          getBasename: () => '/v2',
+        },
+      },
+    });
+
+    const adminLayoutModel: MockAdminLayoutModel = Object.assign(
+      engine.createModel({ uid: 'admin-layout-model', use: 'FlowModel' }),
+      {
+        registerRoutePage: vi.fn(),
+        updateRoutePage: vi.fn(),
+        unregisterRoutePage: vi.fn(),
+      },
+    );
+
+    const { container } = render(
+      <FlowEngineProvider engine={engine}>
+        <MemoryRouter initialEntries={['/admin/371750686228480']}>
+          <Routes>
+            <Route path="/admin/:name" element={<FlowRoute />} />
+          </Routes>
+        </MemoryRouter>
+      </FlowEngineProvider>,
+    );
+
+    await waitFor(() => {
+      expect(listAccessible).toHaveBeenCalled();
+    });
+    expect(container).toBeEmptyDOMElement();
+    expect(screen.queryByText('404')).not.toBeInTheDocument();
+    expect(adminLayoutModel.registerRoutePage).not.toHaveBeenCalled();
+  });
+
+  it('should navigate a current admin group route to its first accessible flow page', async () => {
+    const engine = new FlowEngine();
+    const childRoute = {
+      schemaUid: 'child-flow-page',
+      title: 'Child flow page',
+      type: NocoBaseDesktopRouteType.flowPage,
+    };
+    const groupRoute = {
+      id: 371750686228480,
+      schemaUid: 'group-schema',
+      title: 'Group with child',
+      type: NocoBaseDesktopRouteType.group,
+      children: [childRoute],
+    };
+    const getRouteBySchemaUid = vi.fn((schemaUid: string) =>
+      schemaUid === 'child-flow-page' ? childRoute : undefined,
+    );
+    const listAccessible = vi.fn(() => [groupRoute]);
+    engine.context.defineProperty('routeRepository', {
+      value: {
+        refreshAccessible: hookState.refresh,
+        isAccessibleLoaded: () => true,
+        ensureAccessibleLoaded: vi.fn().mockResolvedValue([]),
+        getRouteBySchemaUid,
+        listAccessible,
+      },
+    });
+    engine.context.defineProperty('app', {
+      value: {
+        getPublicPath: () => '/v2/',
+        router: {
+          getBasename: () => '/v2',
+        },
+      },
+    });
+
+    const adminLayoutModel: MockAdminLayoutModel = Object.assign(
+      engine.createModel({ uid: 'admin-layout-model', use: 'FlowModel' }),
+      {
+        registerRoutePage: vi.fn(),
+        updateRoutePage: vi.fn(),
+        unregisterRoutePage: vi.fn(),
+      },
+    );
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <MemoryRouter initialEntries={['/admin/371750686228480']}>
+          <Routes>
+            <Route path="/admin/:name" element={<FlowRoute />} />
+          </Routes>
+        </MemoryRouter>
+      </FlowEngineProvider>,
+    );
+
+    await waitFor(() => {
+      expect(adminLayoutModel.registerRoutePage).toHaveBeenCalledWith('child-flow-page', expect.any(Object));
+    });
+    expect(adminLayoutModel.registerRoutePage).not.toHaveBeenCalledWith('371750686228480', expect.any(Object));
+    expect(screen.queryByText('404')).not.toBeInTheDocument();
+  });
+
+  it('should keep rendering 404 when a group id is opened with a nested admin route path', async () => {
+    const engine = new FlowEngine();
+    const childRoute = {
+      schemaUid: 'child-flow-page',
+      title: 'Child flow page',
+      type: NocoBaseDesktopRouteType.flowPage,
+    };
+    const groupRoute = {
+      id: 371750686228480,
+      schemaUid: 'group-schema',
+      title: 'Group with child',
+      type: NocoBaseDesktopRouteType.group,
+      children: [childRoute],
+    };
+    engine.context.defineProperty('routeRepository', {
+      value: {
+        refreshAccessible: hookState.refresh,
+        isAccessibleLoaded: () => true,
+        ensureAccessibleLoaded: vi.fn().mockResolvedValue([]),
+        getRouteBySchemaUid: vi.fn((schemaUid: string) => (schemaUid === 'child-flow-page' ? childRoute : undefined)),
+        listAccessible: vi.fn(() => [groupRoute]),
+      },
+    });
+    engine.context.defineProperty('app', {
+      value: {
+        getPublicPath: () => '/v2/',
+        router: {
+          getBasename: () => '/v2',
+        },
+      },
+    });
+
+    const adminLayoutModel: MockAdminLayoutModel = Object.assign(
+      engine.createModel({ uid: 'admin-layout-model', use: 'FlowModel' }),
+      {
+        registerRoutePage: vi.fn(),
+        updateRoutePage: vi.fn(),
+        unregisterRoutePage: vi.fn(),
+      },
+    );
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <MemoryRouter initialEntries={['/admin/371750686228480/view/not-exists']}>
+          <Routes>
+            <Route path="/admin/:name/view/*" element={<FlowRoute />} />
+          </Routes>
+        </MemoryRouter>
+      </FlowEngineProvider>,
+    );
+
+    expect(await screen.findByText('404')).toBeInTheDocument();
+    expect(adminLayoutModel.registerRoutePage).not.toHaveBeenCalledWith('child-flow-page', expect.any(Object));
+    expect(adminLayoutModel.registerRoutePage).not.toHaveBeenCalledWith('371750686228480', expect.any(Object));
+  });
+
+  it('should keep rendering 404 when a group id is opened with a tab admin route path', async () => {
+    const engine = new FlowEngine();
+    const childRoute = {
+      schemaUid: 'child-flow-page',
+      title: 'Child flow page',
+      type: NocoBaseDesktopRouteType.flowPage,
+    };
+    const groupRoute = {
+      id: 371750686228480,
+      schemaUid: 'group-schema',
+      title: 'Group with child',
+      type: NocoBaseDesktopRouteType.group,
+      children: [childRoute],
+    };
+    engine.context.defineProperty('routeRepository', {
+      value: {
+        refreshAccessible: hookState.refresh,
+        isAccessibleLoaded: () => true,
+        ensureAccessibleLoaded: vi.fn().mockResolvedValue([]),
+        getRouteBySchemaUid: vi.fn((schemaUid: string) => (schemaUid === 'child-flow-page' ? childRoute : undefined)),
+        listAccessible: vi.fn(() => [groupRoute]),
+      },
+    });
+    engine.context.defineProperty('app', {
+      value: {
+        getPublicPath: () => '/v2/',
+        router: {
+          getBasename: () => '/v2',
+        },
+      },
+    });
+
+    const adminLayoutModel: MockAdminLayoutModel = Object.assign(
+      engine.createModel({ uid: 'admin-layout-model', use: 'FlowModel' }),
+      {
+        registerRoutePage: vi.fn(),
+        updateRoutePage: vi.fn(),
+        unregisterRoutePage: vi.fn(),
+      },
+    );
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <MemoryRouter initialEntries={['/admin/371750686228480/tab/not-exists']}>
+          <Routes>
+            <Route path="/admin/:name/tab/:tabUid" element={<FlowRoute />} />
+          </Routes>
+        </MemoryRouter>
+      </FlowEngineProvider>,
+    );
+
+    expect(await screen.findByText('404')).toBeInTheDocument();
+    expect(adminLayoutModel.registerRoutePage).not.toHaveBeenCalledWith('child-flow-page', expect.any(Object));
+    expect(adminLayoutModel.registerRoutePage).not.toHaveBeenCalledWith('371750686228480', expect.any(Object));
+  });
+
+  it('should keep blank content while a group child navigation is already pending for the current path', async () => {
+    const engine = new FlowEngine();
+    const childRoute = {
+      schemaUid: 'child-flow-page',
+      title: 'Child flow page',
+      type: NocoBaseDesktopRouteType.flowPage,
+    };
+    const groupRoute = {
+      id: 371750686228480,
+      schemaUid: 'group-schema',
+      title: 'Group with child',
+      type: NocoBaseDesktopRouteType.group,
+      children: [childRoute],
+    };
+    engine.context.defineProperty('routeRepository', {
+      value: {
+        refreshAccessible: hookState.refresh,
+        isAccessibleLoaded: () => true,
+        ensureAccessibleLoaded: vi.fn().mockResolvedValue([]),
+        getRouteBySchemaUid: vi.fn((schemaUid: string) => (schemaUid === 'child-flow-page' ? childRoute : undefined)),
+        listAccessible: vi.fn(() => [groupRoute]),
+      },
+    });
+    engine.context.defineProperty('app', {
+      value: {
+        getPublicPath: () => '/v2/',
+        router: {
+          getBasename: () => '/v2',
+        },
+      },
+    });
+
+    const replace = vi.fn();
+    const navigator: RouterNavigator = {
+      createHref: (to: { pathname?: string; search?: string; hash?: string } | string) =>
+        typeof to === 'string' ? to : `${to.pathname || ''}${to.search || ''}${to.hash || ''}`,
+      go: vi.fn(),
+      push: vi.fn(),
+      replace,
+    };
+
+    const RerenderAfterReplace = () => {
+      const [rerendered, setRerendered] = React.useState(false);
+      React.useEffect(() => {
+        if (!rerendered && replace.mock.calls.length > 0) {
+          setRerendered(true);
+        }
+      }, [rerendered]);
+
+      return <FlowRoute legacyPageBehavior={rerendered ? 'bridge' : undefined} />;
+    };
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <Router location="/admin/371750686228480" navigator={navigator}>
+          <Routes>
+            <Route path="/admin/:name" element={<RerenderAfterReplace />} />
+          </Routes>
+        </Router>
+      </FlowEngineProvider>,
+    );
+
+    await waitFor(() => {
+      expect(replace).toHaveBeenCalled();
+    });
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    });
+    expect(screen.queryByText('404')).not.toBeInTheDocument();
+  });
+
+  it('should reset group navigation guard when page uid changes in the same route instance', async () => {
+    const engine = new FlowEngine();
+    const childRoute1 = {
+      schemaUid: 'child-flow-page-1',
+      title: 'Child flow page 1',
+      type: NocoBaseDesktopRouteType.flowPage,
+    };
+    const childRoute2 = {
+      schemaUid: 'child-flow-page-2',
+      title: 'Child flow page 2',
+      type: NocoBaseDesktopRouteType.flowPage,
+    };
+    const groupRoute1 = {
+      id: 371750686228480,
+      schemaUid: 'group-schema-1',
+      title: 'Group with child 1',
+      type: NocoBaseDesktopRouteType.group,
+      children: [childRoute1],
+    };
+    const groupRoute2 = {
+      id: 371750755434496,
+      schemaUid: 'group-schema-2',
+      title: 'Group with child 2',
+      type: NocoBaseDesktopRouteType.group,
+      children: [childRoute2],
+    };
+    const routeMap: Record<string, typeof childRoute1 | typeof childRoute2> = {
+      'child-flow-page-1': childRoute1,
+      'child-flow-page-2': childRoute2,
+    };
+    const getRouteBySchemaUid = vi.fn((schemaUid: string) => routeMap[schemaUid]);
+    const listAccessible = vi.fn(() => [groupRoute1, groupRoute2]);
+    engine.context.defineProperty('routeRepository', {
+      value: {
+        refreshAccessible: hookState.refresh,
+        isAccessibleLoaded: () => true,
+        ensureAccessibleLoaded: vi.fn().mockResolvedValue([]),
+        getRouteBySchemaUid,
+        listAccessible,
+      },
+    });
+    engine.context.defineProperty('app', {
+      value: {
+        getPublicPath: () => '/v2/',
+        router: {
+          getBasename: () => '/v2',
+        },
+      },
+    });
+
+    const adminLayoutModel: MockAdminLayoutModel = Object.assign(
+      engine.createModel({ uid: 'admin-layout-model', use: 'FlowModel' }),
+      {
+        registerRoutePage: vi.fn(),
+        updateRoutePage: vi.fn(),
+        unregisterRoutePage: vi.fn(),
+      },
+    );
+    let navigateTo: (path: string) => void = () => {};
+    const CaptureNavigate = () => {
+      const navigate = useNavigate();
+      React.useEffect(() => {
+        navigateTo = navigate;
+      }, [navigate]);
+      return null;
+    };
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <MemoryRouter initialEntries={['/admin/371750686228480']}>
+          <CaptureNavigate />
+          <Routes>
+            <Route path="/admin/:name" element={<FlowRoute />} />
+          </Routes>
+        </MemoryRouter>
+      </FlowEngineProvider>,
+    );
+
+    await waitFor(() => {
+      expect(adminLayoutModel.registerRoutePage).toHaveBeenCalledWith('child-flow-page-1', expect.any(Object));
+    });
+
+    act(() => {
+      navigateTo('/admin/371750755434496');
+    });
+
+    await waitFor(() => {
+      expect(adminLayoutModel.registerRoutePage).toHaveBeenCalledWith('child-flow-page-2', expect.any(Object));
+    });
+    expect(adminLayoutModel.registerRoutePage).not.toHaveBeenCalledWith('371750755434496', expect.any(Object));
+    expect(screen.queryByText('404')).not.toBeInTheDocument();
+  });
+
+  it('should keep rendering 404 when current admin route matches no accessible schema uid or id', async () => {
+    const engine = new FlowEngine();
+    engine.context.defineProperty('routeRepository', {
+      value: {
+        refreshAccessible: hookState.refresh,
+        isAccessibleLoaded: () => true,
+        ensureAccessibleLoaded: vi.fn().mockResolvedValue([]),
+        getRouteBySchemaUid: vi.fn(() => undefined),
+        listAccessible: vi.fn(() => [
+          {
+            id: 371750686228480,
+            schemaUid: 'group-schema',
+            title: '789',
+            type: NocoBaseDesktopRouteType.group,
+          },
+        ]),
+      },
+    });
+    engine.context.defineProperty('app', {
+      value: {
+        getPublicPath: () => '/v2/',
+        router: {
+          getBasename: () => '/v2',
+        },
+      },
+    });
+
+    const adminLayoutModel: MockAdminLayoutModel = Object.assign(
+      engine.createModel({ uid: 'admin-layout-model', use: 'FlowModel' }),
+      {
+        registerRoutePage: vi.fn(),
+        updateRoutePage: vi.fn(),
+        unregisterRoutePage: vi.fn(),
+      },
+    );
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <MemoryRouter initialEntries={['/admin/not-exists-4822']}>
+          <Routes>
+            <Route path="/admin/:name" element={<FlowRoute />} />
+          </Routes>
+        </MemoryRouter>
+      </FlowEngineProvider>,
+    );
+
+    expect(await screen.findByText('404')).toBeInTheDocument();
+    expect(adminLayoutModel.registerRoutePage).not.toHaveBeenCalled();
+  });
+
+  it('should keep rendering 404 when current admin route matches only a non-group route id', async () => {
+    const engine = new FlowEngine();
+    engine.context.defineProperty('routeRepository', {
+      value: {
+        refreshAccessible: hookState.refresh,
+        isAccessibleLoaded: () => true,
+        ensureAccessibleLoaded: vi.fn().mockResolvedValue([]),
+        getRouteBySchemaUid: vi.fn(() => undefined),
+        listAccessible: vi.fn(() => [
+          {
+            id: 10001,
+            schemaUid: 'flow-page-schema',
+            title: 'Flow page',
+            type: NocoBaseDesktopRouteType.flowPage,
+          },
+        ]),
+      },
+    });
+    engine.context.defineProperty('app', {
+      value: {
+        getPublicPath: () => '/v2/',
+        router: {
+          getBasename: () => '/v2',
+        },
+      },
+    });
+
+    const adminLayoutModel: MockAdminLayoutModel = Object.assign(
+      engine.createModel({ uid: 'admin-layout-model', use: 'FlowModel' }),
+      {
+        registerRoutePage: vi.fn(),
+        updateRoutePage: vi.fn(),
+        unregisterRoutePage: vi.fn(),
+      },
+    );
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <MemoryRouter initialEntries={['/admin/10001']}>
+          <Routes>
+            <Route path="/admin/:name" element={<FlowRoute />} />
+          </Routes>
+        </MemoryRouter>
+      </FlowEngineProvider>,
+    );
+
+    expect(await screen.findByText('404')).toBeInTheDocument();
+    expect(adminLayoutModel.registerRoutePage).not.toHaveBeenCalled();
+  });
+
+  it('should keep rendering 404 when current admin route matches only a group schema uid', async () => {
+    const engine = new FlowEngine();
+    const groupRoute = {
+      id: 371750686228480,
+      schemaUid: 'group-schema',
+      title: '789',
+      type: NocoBaseDesktopRouteType.group,
+    };
+    engine.context.defineProperty('routeRepository', {
+      value: {
+        refreshAccessible: hookState.refresh,
+        isAccessibleLoaded: () => true,
+        ensureAccessibleLoaded: vi.fn().mockResolvedValue([]),
+        getRouteBySchemaUid: vi.fn((schemaUid: string) => (schemaUid === 'group-schema' ? groupRoute : undefined)),
+        listAccessible: vi.fn(() => [groupRoute]),
+      },
+    });
+    engine.context.defineProperty('app', {
+      value: {
+        getPublicPath: () => '/v2/',
+        router: {
+          getBasename: () => '/v2',
+        },
+      },
+    });
+
+    const adminLayoutModel: MockAdminLayoutModel = Object.assign(
+      engine.createModel({ uid: 'admin-layout-model', use: 'FlowModel' }),
+      {
+        registerRoutePage: vi.fn(),
+        updateRoutePage: vi.fn(),
+        unregisterRoutePage: vi.fn(),
+      },
+    );
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <MemoryRouter initialEntries={['/admin/group-schema']}>
+          <Routes>
+            <Route path="/admin/:name" element={<FlowRoute />} />
+          </Routes>
+        </MemoryRouter>
+      </FlowEngineProvider>,
+    );
+
+    expect(await screen.findByText('404')).toBeInTheDocument();
+    expect(adminLayoutModel.registerRoutePage).not.toHaveBeenCalled();
+  });
+
   it('should not use flowModels:findOne to bridge a missing route for protected layouts', async () => {
     const engine = new FlowEngine();
     const findOne = vi.fn().mockResolvedValue({

package/src/flow/__tests__/getKey.test.ts

@@ -58,4 +58,11 @@ describe('getKey', () => {
 
     expect(getKey(a)).not.toBe(getKey(b));
   });
+
+  it('distinguishes RunJS openView route state overrides', () => {
+    const a = createViewItem({ viewUid: 'v', openViewRouteState: { mode: 'drawer' } }, 0);
+    const b = createViewItem({ viewUid: 'v', openViewRouteState: { mode: 'dialog' } }, 0);
+
+    expect(getKey(a)).not.toBe(getKey(b));
+  });
 });

package/src/flow/__tests__/resolveViewParamsToViewList.test.ts

@@ -250,6 +250,40 @@ describe('resolveViewParamsToViewList', () => {
       expect(result[0].hidden.value).toBe(false); // default drawer type
       expect(result[1].hidden.value).toBe(false); // default drawer type
     });
+
+    it('should let RunJS openView route state override persisted mode for hidden calculation', () => {
+      const model2 = createMockModel('view2', 'drawer');
+      mockFlowEngine.getModel = vi.fn().mockReturnValue(model2);
+
+      const viewParams: ViewParam[] = [
+        { viewUid: 'view1' },
+        { viewUid: 'view2', openViewRouteState: { mode: 'embed' } },
+      ];
+
+      const result = resolveViewParamsToViewList(mockFlowEngine, viewParams, mockRouteModel);
+      updateViewListHidden(result);
+
+      expect(result[0].hidden.value).toBe(true);
+      expect(result[1].hidden.value).toBe(false);
+      expect(model2.getStepParams).not.toHaveBeenCalled();
+    });
+
+    it('should treat child views as embed in mobile hidden calculation', () => {
+      const model2 = createMockModel('view2', 'drawer');
+      mockFlowEngine.getModel = vi.fn().mockReturnValue(model2);
+
+      const viewParams: ViewParam[] = [
+        { viewUid: 'view1' },
+        { viewUid: 'view2', openViewRouteState: { mode: 'dialog' } },
+      ];
+
+      const result = resolveViewParamsToViewList(mockFlowEngine, viewParams, mockRouteModel);
+      updateViewListHidden(result, true);
+
+      expect(result[0].hidden.value).toBe(true);
+      expect(result[1].hidden.value).toBe(false);
+      expect(model2.getStepParams).not.toHaveBeenCalled();
+    });
   });
 
   describe('edge cases', () => {

package/src/flow/actions/__tests__/afterSuccess.test.ts

@@ -0,0 +1,73 @@
+/**
+ * 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 {
+  FlowEngine,
+  FlowModel,
+  FlowRuntimeContext,
+  setupRuntimeContextSteps,
+  type Collection,
+} from '@nocobase/flow-engine';
+import { describe, expect, it } from 'vitest';
+import { afterSuccess, getAfterSuccessResponseRecord, getMetaTreeWithResponseRecord } from '../afterSuccess';
+
+describe('afterSuccess response record variable', () => {
+  it('reads the submit response record from the saveResource step', () => {
+    const record = { id: 1, title: 'Saved' };
+
+    expect(
+      getAfterSuccessResponseRecord({
+        steps: {
+          confirm: { params: {}, result: undefined },
+          saveResource: { params: {}, result: record },
+          afterSuccess: { params: {} },
+        },
+      }),
+    ).toBe(record);
+  });
+
+  it('injects responseRecord into the afterSuccess runtime context', async () => {
+    const record = { id: 1, title: 'Saved' };
+    const sourceCtx = {
+      steps: {
+        saveResource: { params: {}, result: record },
+      },
+      t: (value: string) => value,
+    };
+    const properties = await afterSuccess.defineProperties(sourceCtx as FlowRuntimeContext);
+
+    expect(properties.responseRecord.get()).toBe(record);
+  });
+
+  it('shows responseRecord in the variable picker for settings context', () => {
+    const engine = new FlowEngine();
+    class SubmitActionModel extends FlowModel {}
+    engine.registerModels({ SubmitActionModel });
+    const model = engine.createModel<SubmitActionModel>({ use: 'SubmitActionModel' });
+    const collection = {
+      name: 'users',
+      dataSourceKey: 'main',
+      getFilterByTK: (record: { id?: number }) => record.id,
+    } as unknown as Collection;
+    model.context.defineProperty('collection', { value: collection });
+    const flow = model.registerFlow({
+      key: 'submitSettings',
+      steps: {
+        saveResource: { title: 'Save record', handler: () => undefined },
+        afterSuccess: { use: 'afterSuccess' },
+      },
+    });
+    const ctx = new FlowRuntimeContext(model, 'submitSettings', 'settings');
+    setupRuntimeContextSteps(ctx, flow.steps, model, 'submitSettings');
+
+    const metaTree = getMetaTreeWithResponseRecord(ctx);
+
+    expect(metaTree.find((node) => node.name === 'responseRecord')?.title).toBe('Response record');
+  });
+});