@nocobase/client-v2 2.1.11 → 2.2.0-alpha.2

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

@@ -13,6 +13,7 @@ import { MemoryRouter, Route, Routes } from 'react-router-dom';
 import { 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';
 
 type MockAdminLayoutModel = FlowModel & {
   registerRoutePage: ReturnType<typeof vi.fn>;
@@ -321,6 +322,94 @@ describe('FlowRoute', () => {
     });
   });
 
+  it('should ensure accessible routes for the current layout before bridging', async () => {
+    const engine = new FlowEngine();
+    const request = vi.fn().mockResolvedValue({
+      data: {
+        data: [
+          {
+            type: 'flowPage',
+            schemaUid: 'mobile-page',
+          },
+        ],
+      },
+    });
+    const routeRepository = new RouteRepository({
+      api: {
+        request,
+        resource: vi.fn(),
+      },
+    } as never);
+    routeRepository.setRoutes([], 'admin-layout-model');
+    const deactivateLayout = routeRepository.activateLayout({
+      uid: 'mobile-layout-model',
+    });
+    engine.context.defineProperty('routeRepository', {
+      value: routeRepository,
+    });
+    engine.context.defineProperty('app', {
+      value: {
+        getPublicPath: () => '/v2/',
+        router: {
+          getBasename: () => '/v2',
+        },
+      },
+    });
+    const routeModel = engine.createModel({
+      uid: 'mobile-route-model',
+      use: 'FlowModel',
+    });
+    routeModel.context.defineProperty('layout', {
+      value: {
+        routeName: 'mobile',
+        routePath: '/mobile',
+        rootRouteName: 'mobile',
+        uid: 'mobile-layout-model',
+        layoutModelClass: 'MobileLayoutModel',
+        rootPageModelClass: 'MobileRootPageModel',
+        childPageModelClass: 'MobileChildPageModel',
+        authCheck: true,
+      },
+    });
+
+    const mobileLayoutModel: MockAdminLayoutModel = Object.assign(
+      engine.createModel({
+        uid: 'mobile-layout-model',
+        use: 'FlowModel',
+      }),
+      {
+        registerRoutePage: vi.fn(),
+        updateRoutePage: vi.fn(),
+        unregisterRoutePage: vi.fn(),
+      },
+    );
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <FlowContextProvider context={routeModel.context}>
+          <MemoryRouter initialEntries={['/mobile/mobile-page']}>
+            <Routes>
+              <Route path="/mobile/:name" element={<FlowRoute />} />
+            </Routes>
+          </MemoryRouter>
+        </FlowContextProvider>
+      </FlowEngineProvider>,
+    );
+
+    await waitFor(() => {
+      expect(request).toHaveBeenCalledWith({
+        url: '/desktopRoutes:listAccessible',
+        params: {
+          tree: true,
+          sort: 'sort',
+          layout: 'mobile-layout-model',
+        },
+      });
+      expect(mobileLayoutModel.registerRoutePage).toHaveBeenCalledWith('mobile-page', expect.any(Object));
+    });
+    deactivateLayout();
+  });
+
   it('should fail fast when admin-layout-model is missing', () => {
     const engine = new FlowEngine();
     engine.context.defineProperty('route', {
@@ -420,6 +509,75 @@ describe('FlowRoute', () => {
     });
   });
 
+  it('should not rerun accessible guard when layout reference changes but fields stay the same', async () => {
+    const engine = new FlowEngine();
+    const ensureAccessibleLoaded = vi.fn().mockResolvedValue([]);
+    const getRouteBySchemaUid = vi.fn(() => ({ type: 'flowPage', schemaUid: 'test-page' }));
+    engine.context.defineProperty('routeRepository', {
+      value: {
+        refreshAccessible: hookState.refresh,
+        isAccessibleLoaded: () => true,
+        ensureAccessibleLoaded,
+        getRouteBySchemaUid,
+      },
+    });
+    engine.context.defineProperty('app', {
+      value: {
+        getPublicPath: () => '/v2/',
+        router: {
+          getBasename: () => '/v2',
+        },
+      },
+    });
+
+    const layoutModel: MockAdminLayoutModel = Object.assign(
+      engine.createModel({ uid: 'legacy-admin-layout-model', use: 'FlowModel' }),
+      {
+        registerRoutePage: vi.fn(),
+        updateRoutePage: vi.fn(),
+        unregisterRoutePage: vi.fn(),
+      },
+    );
+    let layoutReadCount = 0;
+    const stableLayout = {
+      uid: 'admin-layout-model',
+      routeName: 'admin',
+      routePath: '/admin',
+      authCheck: true,
+    };
+    Object.defineProperty(layoutModel, 'layout', {
+      get: () => {
+        layoutReadCount += 1;
+        return layoutReadCount <= 2 ? { ...stableLayout } : stableLayout;
+      },
+    });
+
+    const element = (
+      <FlowEngineProvider engine={engine}>
+        <MemoryRouter initialEntries={['/flow/test-page']}>
+          <Routes>
+            <Route path="/flow/:name" element={<FlowRoute getLayoutModel={() => layoutModel as any} />} />
+          </Routes>
+        </MemoryRouter>
+      </FlowEngineProvider>
+    );
+    const { rerender } = render(element);
+
+    await waitFor(() => {
+      expect(layoutModel.registerRoutePage).toHaveBeenCalledWith('test-page', expect.any(Object));
+    });
+    expect(ensureAccessibleLoaded).not.toHaveBeenCalled();
+    expect(getRouteBySchemaUid).toHaveBeenCalledTimes(1);
+
+    rerender(element);
+
+    await waitFor(() => {
+      expect(layoutModel.updateRoutePage).toHaveBeenCalled();
+    });
+    expect(ensureAccessibleLoaded).not.toHaveBeenCalled();
+    expect(getRouteBySchemaUid).toHaveBeenCalledTimes(1);
+  });
+
   it('should show 404 when current route is a legacy page in v2 runtime', async () => {
     const originalLocation = window.location;
     const replace = vi.fn();
@@ -571,6 +729,22 @@ describe('FlowRoute', () => {
         },
       },
     });
+    const routeModel = engine.createModel({
+      uid: 'public-form-route-model',
+      use: 'FlowModel',
+    });
+    routeModel.context.defineProperty('layout', {
+      value: {
+        routeName: 'public-forms',
+        routePath: '/public-forms',
+        rootRouteName: 'public-forms',
+        uid: 'public-form-layout-model',
+        layoutModelClass: 'PublicFormLayoutModel',
+        rootPageModelClass: 'PublicFormPageModel',
+        childPageModelClass: 'ChildPageModel',
+        authCheck: false,
+      },
+    });
 
     const layoutModel: MockAdminLayoutModel = Object.assign(
       engine.createModel({ uid: 'public-form-layout-model', use: 'FlowModel' }),
@@ -581,13 +755,82 @@ describe('FlowRoute', () => {
       },
     );
 
+    render(
+      <FlowEngineProvider engine={engine}>
+        <FlowContextProvider context={routeModel.context}>
+          <MemoryRouter initialEntries={['/public-forms/public-form-1']}>
+            <Routes>
+              <Route
+                path="/public-forms/:name"
+                element={<FlowRoute legacyPageBehavior="notFound" getLayoutModel={() => layoutModel} />}
+              />
+            </Routes>
+          </MemoryRouter>
+        </FlowContextProvider>
+      </FlowEngineProvider>,
+    );
+
+    await waitFor(() => {
+      expect(layoutModel.registerRoutePage).toHaveBeenCalledWith('public-form-1', expect.any(Object));
+    });
+    expect(screen.queryByText('404')).not.toBeInTheDocument();
+  });
+
+  it('should use getLayoutModel layout authCheck when FlowContext has no layout', async () => {
+    const engine = new FlowEngine();
+    engine.setModelRepository({
+      findOne: vi.fn().mockResolvedValue({
+        uid: 'public-form-1',
+        use: 'FlowModel',
+      }),
+      save: vi.fn(),
+      destroy: vi.fn(),
+    } as any);
+    engine.context.defineProperty('routeRepository', {
+      value: {
+        refreshAccessible: hookState.refresh,
+        isAccessibleLoaded: () => true,
+        ensureAccessibleLoaded: vi.fn().mockResolvedValue([]),
+        getRouteBySchemaUid: vi.fn(() => undefined),
+      },
+    });
+    engine.context.defineProperty('app', {
+      value: {
+        getPublicPath: () => '/v2/',
+        router: {
+          getBasename: () => '/v2',
+        },
+      },
+    });
+
+    const layoutModel: MockAdminLayoutModel = Object.assign(
+      engine.createModel({ uid: 'public-form-layout-model', use: 'FlowModel' }),
+      {
+        registerRoutePage: vi.fn(),
+        updateRoutePage: vi.fn(),
+        unregisterRoutePage: vi.fn(),
+      },
+    );
+    Object.defineProperty(layoutModel, 'layout', {
+      value: {
+        routeName: 'public-forms',
+        routePath: '/public-forms',
+        rootRouteName: 'public-forms',
+        uid: 'public-form-layout-model',
+        layoutModelClass: 'PublicFormLayoutModel',
+        rootPageModelClass: 'PublicFormPageModel',
+        childPageModelClass: 'ChildPageModel',
+        authCheck: false,
+      },
+    });
+
     render(
       <FlowEngineProvider engine={engine}>
         <MemoryRouter initialEntries={['/public-forms/public-form-1']}>
           <Routes>
             <Route
               path="/public-forms/:name"
-              element={<FlowRoute legacyPageBehavior="notFound" getLayoutModel={() => layoutModel} />}
+              element={<FlowRoute legacyPageBehavior="notFound" getLayoutModel={() => layoutModel as any} />}
             />
           </Routes>
         </MemoryRouter>
@@ -600,6 +843,202 @@ describe('FlowRoute', () => {
     expect(screen.queryByText('404')).not.toBeInTheDocument();
   });
 
+  it('should render not found when admin route is not accessible', async () => {
+    const engine = new FlowEngine();
+    engine.setModelRepository({
+      findOne: vi.fn().mockResolvedValue({
+        uid: 'admin-denied-page',
+        use: 'FlowModel',
+      }),
+      save: vi.fn(),
+      destroy: vi.fn(),
+    } as any);
+    engine.context.defineProperty('routeRepository', {
+      value: {
+        refreshAccessible: hookState.refresh,
+        isAccessibleLoaded: () => true,
+        ensureAccessibleLoaded: vi.fn().mockResolvedValue([]),
+        getRouteBySchemaUid: vi.fn(() => undefined),
+      },
+    });
+    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/admin-denied-page']}>
+          <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({
+      uid: 'mobile-denied-page',
+      use: 'FlowModel',
+    });
+    engine.setModelRepository({
+      findOne,
+      save: vi.fn(),
+      destroy: vi.fn(),
+    } as any);
+    engine.context.defineProperty('routeRepository', {
+      value: {
+        refreshAccessible: hookState.refresh,
+        isAccessibleLoaded: () => true,
+        ensureAccessibleLoaded: vi.fn().mockResolvedValue([]),
+        getRouteBySchemaUid: vi.fn(() => undefined),
+      },
+    });
+    engine.context.defineProperty('app', {
+      value: {
+        getPublicPath: () => '/v2/',
+        router: {
+          getBasename: () => '/v2',
+        },
+      },
+    });
+    const routeModel = engine.createModel({
+      uid: 'mobile-route-model',
+      use: 'FlowModel',
+    });
+    routeModel.context.defineProperty('layout', {
+      value: {
+        routeName: 'mobile',
+        routePath: '/mobile',
+        rootRouteName: 'mobile',
+        uid: 'mobile-layout-model',
+        layoutModelClass: 'MobileLayoutModel',
+        rootPageModelClass: 'MobileRootPageModel',
+        childPageModelClass: 'MobileChildPageModel',
+        authCheck: true,
+      },
+    });
+
+    const layoutModel: MockAdminLayoutModel = Object.assign(
+      engine.createModel({ uid: 'mobile-layout-model', use: 'FlowModel' }),
+      {
+        registerRoutePage: vi.fn(),
+        updateRoutePage: vi.fn(),
+        unregisterRoutePage: vi.fn(),
+      },
+    );
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <FlowContextProvider context={routeModel.context}>
+          <MemoryRouter initialEntries={['/mobile/mobile-denied-page']}>
+            <Routes>
+              <Route
+                path="/mobile/:name"
+                element={<FlowRoute legacyPageBehavior="notFound" getLayoutModel={() => layoutModel} />}
+              />
+            </Routes>
+          </MemoryRouter>
+        </FlowContextProvider>
+      </FlowEngineProvider>,
+    );
+
+    expect(await screen.findByText('404')).toBeInTheDocument();
+    expect(findOne).not.toHaveBeenCalled();
+    expect(layoutModel.registerRoutePage).not.toHaveBeenCalled();
+  });
+
+  it('should not load a known page uid when a protected custom layout has no accessible route', async () => {
+    const engine = new FlowEngine();
+    const findOne = vi.fn().mockResolvedValue({
+      uid: 'known-denied-custom-page',
+      use: 'FlowModel',
+    });
+    engine.setModelRepository({
+      findOne,
+      save: vi.fn(),
+      destroy: vi.fn(),
+    } as any);
+    engine.context.defineProperty('routeRepository', {
+      value: {
+        refreshAccessible: hookState.refresh,
+        isAccessibleLoaded: () => true,
+        ensureAccessibleLoaded: vi.fn().mockResolvedValue([]),
+        getRouteBySchemaUid: vi.fn(() => undefined),
+      },
+    });
+    engine.context.defineProperty('app', {
+      value: {
+        getPublicPath: () => '/v2/',
+        router: {
+          getBasename: () => '/v2',
+        },
+      },
+    });
+    const routeModel = engine.createModel({
+      uid: 'custom-layout-route-model',
+      use: 'FlowModel',
+    });
+    routeModel.context.defineProperty('layout', {
+      value: {
+        routeName: 'admin2',
+        routePath: '/admin2',
+        rootRouteName: 'admin2',
+        uid: 'custom-protected-layout-model',
+        layoutModelClass: 'AdminLayoutModel',
+        rootPageModelClass: 'RootPageModel',
+        childPageModelClass: 'ChildPageModel',
+        authCheck: true,
+      },
+    });
+
+    const layoutModel: MockAdminLayoutModel = Object.assign(
+      engine.createModel({ uid: 'custom-protected-layout-model', use: 'FlowModel' }),
+      {
+        registerRoutePage: vi.fn(),
+        updateRoutePage: vi.fn(),
+        unregisterRoutePage: vi.fn(),
+      },
+    );
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <FlowContextProvider context={routeModel.context}>
+          <MemoryRouter initialEntries={['/admin2/known-denied-custom-page']}>
+            <Routes>
+              <Route
+                path="/admin2/:name"
+                element={<FlowRoute legacyPageBehavior="notFound" getLayoutModel={() => layoutModel} />}
+              />
+            </Routes>
+          </MemoryRouter>
+        </FlowContextProvider>
+      </FlowEngineProvider>,
+    );
+
+    expect(await screen.findByText('404')).toBeInTheDocument();
+    expect(findOne).not.toHaveBeenCalled();
+    expect(layoutModel.registerRoutePage).not.toHaveBeenCalled();
+  });
+
   it('should check model existence without occupying the route model uid', async () => {
     const engine = new FlowEngine();
     const findOne = vi.fn().mockResolvedValue({
@@ -817,7 +1256,7 @@ describe('FlowRoute', () => {
     }
   });
 
-  it('should not redirect when route does not exist', async () => {
+  it('should render not found without redirecting when admin route does not exist', async () => {
     const originalLocation = window.location;
     const replace = vi.fn();
     Object.defineProperty(window, 'location', {
@@ -866,9 +1305,8 @@ describe('FlowRoute', () => {
         </FlowEngineProvider>,
       );
 
-      await waitFor(() => {
-        expect(adminLayoutModel.registerRoutePage).toHaveBeenCalled();
-      });
+      expect(await screen.findByText('404')).toBeInTheDocument();
+      expect(adminLayoutModel.registerRoutePage).not.toHaveBeenCalled();
       expect(replace).not.toHaveBeenCalled();
     } finally {
       Object.defineProperty(window, 'location', {

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');
+  });
+});