@nocobase/client-v2 2.1.0-alpha.45 → 2.1.0-alpha.46

package/src/components/form/__tests__/TypedVariableInput.test.tsx

@@ -0,0 +1,152 @@
+/**
+ * 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 { FlowContext, FlowContextProvider } from '@nocobase/flow-engine';
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import React from 'react';
+import { describe, expect, it, vi } from 'vitest';
+import { TypedVariableInput } from '../TypedVariableInput';
+
+function createContextWithEnv() {
+  const ctx = new FlowContext();
+  (ctx as any).t = (key: string) => key;
+
+  ctx.defineProperty('$env', {
+    value: { SMTP_PORT: 465, SECURE_FLAG: true },
+    meta: {
+      title: 'Env',
+      type: 'object',
+      properties: {
+        SMTP_PORT: { title: 'SMTP Port', type: 'number' },
+        SECURE_FLAG: { title: 'Secure flag', type: 'boolean' },
+      },
+    },
+  });
+
+  return ctx;
+}
+
+function renderWithCtx(ctx: FlowContext, node: React.ReactNode) {
+  return render(<FlowContextProvider context={ctx}>{node}</FlowContextProvider>);
+}
+
+describe('TypedVariableInput - constant rendering', () => {
+  it('renders an InputNumber for a numeric value when types=[number]', async () => {
+    const ctx = createContextWithEnv();
+    renderWithCtx(
+      ctx,
+      <TypedVariableInput
+        value={465}
+        types={[['number', { min: 1, max: 65535 }]]}
+        namespaces={['$env']}
+        onChange={() => undefined}
+      />,
+    );
+    const numberInput = await screen.findByDisplayValue('465');
+    expect(numberInput).toBeInTheDocument();
+    expect(numberInput.getAttribute('role')).toBe('spinbutton');
+  });
+
+  it('renders a boolean Select when value is true and types=[boolean]', async () => {
+    const ctx = createContextWithEnv();
+    renderWithCtx(
+      ctx,
+      <TypedVariableInput value={true} types={['boolean']} namespaces={['$env']} onChange={() => undefined} />,
+    );
+    await waitFor(() => {
+      // antd Select renders the chosen item label via a selection-item span
+      const item = screen.getByText('True');
+      expect(item).toBeInTheDocument();
+    });
+  });
+
+  it('renders the Null placeholder when value=null and nullable=true', async () => {
+    const ctx = createContextWithEnv();
+    renderWithCtx(
+      ctx,
+      <TypedVariableInput value={null} types={['number']} namespaces={['$env']} nullable onChange={() => undefined} />,
+    );
+    // Uses placeholder slot (not value) so antd's grey placeholder colour
+    // applies — see comment in TypedVariableInput.tsx.
+    const nullInput = await screen.findByPlaceholderText('<Null>');
+    expect(nullInput).toBeInTheDocument();
+    expect(nullInput.getAttribute('readonly')).not.toBeNull();
+  });
+});
+
+describe('TypedVariableInput - variable rendering', () => {
+  it('renders a labelled pill when value is a {{ $env.X }} expression', async () => {
+    const ctx = createContextWithEnv();
+    renderWithCtx(
+      ctx,
+      <TypedVariableInput
+        value="{{$env.SMTP_PORT}}"
+        types={['number']}
+        namespaces={['$env']}
+        onChange={() => undefined}
+      />,
+    );
+    await waitFor(() => {
+      const tag = screen.getByRole('button', { name: 'variable-tag' });
+      expect(tag.textContent).toContain('Env');
+      expect(tag.textContent).toContain('SMTP Port');
+    });
+  });
+
+  it('clears back to null when the close button is clicked (nullable=true)', async () => {
+    const ctx = createContextWithEnv();
+    const handleChange = vi.fn();
+    renderWithCtx(
+      ctx,
+      <TypedVariableInput
+        value="{{$env.SMTP_PORT}}"
+        types={['number']}
+        namespaces={['$env']}
+        nullable
+        onChange={handleChange}
+      />,
+    );
+    const clear = await screen.findByRole('button', { name: 'icon-close' });
+    fireEvent.click(clear);
+    expect(handleChange).toHaveBeenCalledWith(null);
+  });
+
+  it('clears back to default-of-first-type when nullable=false', async () => {
+    const ctx = createContextWithEnv();
+    const handleChange = vi.fn();
+    renderWithCtx(
+      ctx,
+      <TypedVariableInput
+        value="{{$env.SMTP_PORT}}"
+        types={['number']}
+        namespaces={['$env']}
+        nullable={false}
+        onChange={handleChange}
+      />,
+    );
+    const clear = await screen.findByRole('button', { name: 'icon-close' });
+    fireEvent.click(clear);
+    expect(handleChange).toHaveBeenCalledWith(0);
+  });
+});
+
+describe('TypedVariableInput - editor onChange propagation', () => {
+  it('forwards numeric edits via onChange', async () => {
+    const ctx = createContextWithEnv();
+    const handleChange = vi.fn();
+    renderWithCtx(ctx, <TypedVariableInput value={465} types={['number']} onChange={handleChange} />);
+    const numberInput = await screen.findByDisplayValue('465');
+    fireEvent.change(numberInput, { target: { value: '587' } });
+    // antd InputNumber may emit on blur; force blur to flush
+    fireEvent.blur(numberInput);
+    expect(handleChange).toHaveBeenCalled();
+    const lastCall = handleChange.mock.calls[handleChange.mock.calls.length - 1][0];
+    expect(lastCall).toBe(587);
+  });
+});

package/src/components/form/index.tsx

@@ -16,4 +16,5 @@ export * from './FileSizeInput';
 export * from './JsonTextArea';
 export * from './PasswordInput';
 export * from './RemoteSelect';
+export * from './TypedVariableInput';
 export * from './VariableInput';

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

@@ -8,7 +8,7 @@
  */
 
 import React from 'react';
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+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 { FlowContextProvider, FlowEngine, FlowEngineProvider, type FlowModel } from '@nocobase/flow-engine';
@@ -32,6 +32,13 @@ describe('FlowRoute', () => {
   beforeEach(() => {
     vi.clearAllMocks();
     hookState.refresh = vi.fn();
+    // Fixtures mount the modern client under the `v2` segment; tell the
+    // runtime-prefix helper so v2-runtime detection matches.
+    (globalThis.window as any).__nocobase_modern_client_prefix__ = 'v2';
+  });
+
+  afterEach(() => {
+    delete (globalThis.window as any).__nocobase_modern_client_prefix__;
   });
 
   it('should bridge page lifecycle to admin-layout-model', async () => {

package/src/flow/actions/__tests__/linkageRules.hiddenSync.restore.test.ts

@@ -0,0 +1,100 @@
+/**
+ * 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 { actionLinkageRules } from '../linkageRules';
+
+function createRule(actions: any[]) {
+  return {
+    key: 'r1',
+    title: 'r1',
+    enable: true,
+    condition: { logic: '$and', items: [] },
+    actions,
+  };
+}
+
+describe('linkageRules hidden state propagation', () => {
+  it('restores hidden state to same-target models when reverting to original props', async () => {
+    const blockModel = { uid: 'block-1' };
+
+    const hostModel: any = {
+      uid: 'host',
+      hidden: false,
+      context: { blockModel },
+      __allModels: [],
+      setProps: vi.fn(),
+      getFlow: vi.fn(() => ({})),
+      getStepParams: vi.fn((_flowKey: string, stepKey: string) => {
+        if (stepKey === 'init') return { fieldPath: 'org_m2o' };
+        return undefined;
+      }),
+      translate: (s: string) => s,
+    };
+
+    const sameTargetModel: any = {
+      uid: 'same-target',
+      hidden: false,
+      context: { blockModel },
+      setProps: vi.fn(),
+      getStepParams: vi.fn((_flowKey: string, stepKey: string) => {
+        if (stepKey === 'init') return { fieldPath: 'org_m2o' };
+        return undefined;
+      }),
+      translate: (s: string) => s,
+    };
+
+    const engine = {
+      forEachModel: (visitor: (m: any) => void) => {
+        [hostModel, sameTargetModel].forEach(visitor);
+      },
+    };
+
+    const ctx: any = {
+      flowKey: 'buttonSettings',
+      model: hostModel,
+      engine,
+      app: {
+        jsonLogic: {
+          apply: vi.fn(() => true),
+        },
+      },
+      resolveJsonTemplate: vi.fn(async (value: any) => value),
+      getAction: (name: string) => {
+        if (name !== 'linkageSetActionProps') return undefined;
+        return {
+          handler: async (_ctx: any, params: any) => {
+            params.setProps(hostModel, {
+              hiddenModel: params.value === 'hidden',
+              disabled: false,
+              hiddenText: false,
+            });
+          },
+        };
+      },
+    };
+
+    await actionLinkageRules.handler(ctx, {
+      value: [
+        createRule([
+          {
+            name: 'linkageSetActionProps',
+            params: { value: 'hidden' },
+          },
+        ]),
+      ],
+    });
+    expect(hostModel.hidden).toBe(true);
+    expect(sameTargetModel.hidden).toBe(true);
+
+    await actionLinkageRules.handler(ctx, { value: [] });
+    expect(hostModel.hidden).toBe(false);
+    expect(sameTargetModel.hidden).toBe(false);
+  });
+});

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

@@ -46,7 +46,7 @@ describe('linkageRulesRefresh action', () => {
     expect(handler).not.toHaveBeenCalled();
   });
 
-  it('runs linkage action on master model when forks are not mounted in runtime mode', async () => {
+  it('skips master model when forks can handle flow even if regular action buttons do not attach refs', async () => {
     const handler = vi.fn(async () => {});
     const model: any = {
       isFork: false,
@@ -74,6 +74,28 @@ describe('linkageRulesRefresh action', () => {
       flowKey: 'buttonSettings',
     });
 
+    expect(handler).not.toHaveBeenCalled();
+  });
+
+  it('runs linkage action on master model when no forks exist in runtime mode', async () => {
+    const handler = vi.fn(async () => {});
+    const model: any = {
+      isFork: false,
+      forks: new Set(),
+      getFlow: vi.fn(() => ({})),
+      getStepParams: vi.fn(() => ({ value: ['master-runtime'] })),
+    };
+    const ctx: any = {
+      model,
+      resolveJsonTemplate: vi.fn(async (p: any) => p),
+      getAction: vi.fn(() => ({ handler })),
+    };
+
+    await linkageRulesRefresh.handler(ctx, {
+      actionName: 'actionLinkageRules',
+      flowKey: 'buttonSettings',
+    });
+
     expect(handler).toHaveBeenCalledWith(ctx, { value: ['master-runtime'] });
   });
 

package/src/flow/actions/dataScope.tsx

@@ -33,7 +33,14 @@ export const dataScope = defineAction({
         return (
           <FilterGroup
             value={props.value}
-            FilterItem={(p) => <VariableFilterItem {...p} model={flowContext.model} rightAsVariable />}
+            FilterItem={(p) => (
+              <VariableFilterItem
+                {...p}
+                model={flowContext.model}
+                rightAsVariable
+                maxAssociationFieldDepth={flowContext.model instanceof FieldModel ? undefined : 2}
+              />
+            )}
           />
         );
       },

package/src/flow/actions/linkageRules.tsx

@@ -1606,7 +1606,9 @@ const LinkageRulesUI = observer(
             <div style={{ paddingLeft: 12 }}>
               <FilterGroup
                 value={rule.condition}
-                FilterItem={(props) => <LinkageFilterItem model={ctx.model} value={props.value} />}
+                FilterItem={(props) => (
+                  <LinkageFilterItem model={ctx.model} value={props.value} maxAssociationFieldDepth={2} />
+                )}
               />
             </div>
           </div>
@@ -2099,16 +2101,17 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
   mergedByUid.forEach((model: any, uid) => {
     const patchProps = mergedPropsByUid.get(uid) || {};
     const newProps = { ...model.__originalProps, ...patchProps };
-    const hasHiddenModelPatch = Object.prototype.hasOwnProperty.call(patchProps, 'hiddenModel');
+    const prevHidden = !!model.hidden;
+    const nextHidden = !!newProps.hiddenModel;
 
     model.setProps(_.omit(newProps, ['hiddenModel', 'value', 'hiddenText']));
     syncFieldOptionsToForks(model, patchProps);
     if (typeof model.setHidden === 'function') {
       model.setHidden(!!newProps.hiddenModel);
     } else {
-      model.hidden = !!newProps.hiddenModel;
-      if (hasHiddenModelPatch) {
-        hiddenStatePatches.push({ model, hidden: model.hidden });
+      model.hidden = nextHidden;
+      if (prevHidden !== nextHidden) {
+        hiddenStatePatches.push({ model, hidden: nextHidden });
       }
     }
 

package/src/flow/actions/linkageRulesRefresh.tsx

@@ -41,16 +41,15 @@ export const linkageRulesRefresh = defineAction({
     const flowSettingsEnabled = Boolean(
       (ctx as any)?.flowSettingsEnabled || (model as any)?.context?.flowSettingsEnabled,
     );
-    const hasMountedForkWithFlow =
+    const hasForkWithFlow =
       !model?.isFork &&
       !!model?.forks?.size &&
       Array.from(model?.forks || []).some((fork: any) => {
         if (!fork || fork.disposed) return false;
-        if (!fork?.context?.ref?.current) return false;
         return !!fork?.getFlow?.(flowKey);
       });
     const isMasterMounted = Boolean((model as any)?.context?.ref?.current);
-    if (hasMountedForkWithFlow && !isMasterMounted && !flowSettingsEnabled) {
+    if (hasForkWithFlow && !isMasterMounted && !flowSettingsEnabled) {
       return;
     }
 

package/src/flow/actions/setTargetDataScope.tsx

@@ -135,7 +135,7 @@ function SetTargetDataScope(props) {
   return (
     <FilterGroup
       value={props.value}
-      FilterItem={(p) => <VariableFilterItem {...p} model={targetModel} rightAsVariable />}
+      FilterItem={(p) => <VariableFilterItem {...p} model={targetModel} rightAsVariable maxAssociationFieldDepth={2} />}
     />
   );
 }

package/src/flow/admin-shell/admin-layout/AdminLayoutMenuModels.tsx

@@ -55,6 +55,15 @@ const insertPositionToMethod = {
   afterEnd: 'insertAfter',
 } as const;
 
+const omitMenuRuntimeProps = (props: Record<string, unknown> = {}) => {
+  const persistableProps = { ...props };
+  delete persistableProps.item;
+  delete persistableProps.dom;
+  delete persistableProps.options;
+  delete persistableProps.renderType;
+  return persistableProps;
+};
+
 export class AdminLayoutMenuItemModel extends FlowModel<AdminLayoutMenuItemStructure> {
   private creationPersisted = false;
   private persistedStateHydrated = false;
@@ -261,6 +270,12 @@ export class AdminLayoutMenuItemModel extends FlowModel<AdminLayoutMenuItemStruc
     return currentFlowCount > 0 || initialFlowCount > 0;
   }
 
+  serialize(): ReturnType<FlowModel['serialize']> {
+    const data = super.serialize();
+    data.props = omitMenuRuntimeProps(data.props);
+    return data;
+  }
+
   setHidden(value: boolean) {
     const previous = this.hidden;
     super.setHidden(value);
@@ -698,7 +713,6 @@ AdminLayoutMenuItemModel.registerFlow({
 AdminLayoutMenuItemModel.registerFlow({
   key: 'menuSettings',
   title: 'Menu settings',
-  manual: true,
   steps: {
     edit: {
       title: 'Edit',

package/src/flow/admin-shell/admin-layout/__tests__/AdminLayoutMenuModels.test.ts

@@ -9,7 +9,7 @@
 
 import React from 'react';
 import { act, fireEvent, render, screen, waitFor } from '@testing-library/react';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { FlowEngine, FlowEngineProvider } from '@nocobase/flow-engine';
 import { observer } from '@nocobase/flow-engine';
 import { MemoryRouter } from 'react-router-dom';
@@ -45,6 +45,9 @@ describe('AdminLayoutModel menu items', () => {
   let modalConfirmMock: ReturnType<typeof vi.fn>;
 
   beforeEach(() => {
+    // Fixtures mount the modern client under the `v2` segment; tell the
+    // runtime-prefix helper so v2-runtime detection matches.
+    (globalThis.window as any).__nocobase_modern_client_prefix__ = 'v2';
     engine = new FlowEngine();
     modalConfirmMock = vi.fn().mockResolvedValue(true);
     engine.registerModels({
@@ -104,6 +107,10 @@ describe('AdminLayoutModel menu items', () => {
     vi.spyOn(window, 'open').mockImplementation(() => null);
   });
 
+  afterEach(() => {
+    delete (globalThis.window as any).__nocobase_modern_client_prefix__;
+  });
+
   const createRoute = (options?: Partial<import('../../../../flow-compat').NocoBaseDesktopRoute>) => ({
     id: 1,
     title: 'Page 1',
@@ -950,6 +957,73 @@ describe('AdminLayoutModel menu items', () => {
     });
   });
 
+  it('should save menu linkage rules without serializing runtime render props', async () => {
+    type SerializedFlowModel = Record<string, unknown> & {
+      props?: Record<string, unknown>;
+      subModels?: unknown;
+    };
+    const save = vi.fn(
+      async (targetModel: { serialize: () => SerializedFlowModel }, options?: { onlyStepParams?: boolean }) => {
+        const data = targetModel.serialize();
+        if (options?.onlyStepParams) {
+          delete data.subModels;
+        }
+
+        expect(data.props?.item).toBeUndefined();
+        expect(data.props?.dom).toBeUndefined();
+        expect(data.props?.options).toBeUndefined();
+        expect(data.props?.renderType).toBeUndefined();
+        expect(() => JSON.stringify(data)).not.toThrow();
+        return data;
+      },
+    );
+    const updateRoute = vi.fn().mockResolvedValue(undefined);
+    engine.setModelRepository({ save } as Parameters<FlowEngine['setModelRepository']>[0]);
+    engine.context.routeRepository.updateRoute = updateRoute;
+
+    const route = createRoute();
+    const model = engine.createModel<AdminLayoutMenuItemModel>({
+      uid: 'menu-item-linkage-runtime-props',
+      use: AdminLayoutMenuItemModel,
+      props: {
+        route,
+      },
+    });
+    const item = {
+      name: 'Page 1',
+      path: '/admin/page-1',
+      _route: route,
+      _model: model,
+    };
+
+    model.setProps({
+      item,
+      dom: React.createElement('span', null, 'Page 1'),
+      renderType: 'item',
+      options: { collapsed: false },
+    });
+    model.setStepParams('menuSettings', 'linkageRules', {
+      value: [
+        {
+          key: 'r1',
+          title: 'Hide menu item',
+          enable: true,
+          condition: { logic: '$and', items: [] },
+          actions: [{ key: 'a1', name: 'linkageSetMenuItemProps', params: { value: 'hidden' } }],
+        },
+      ],
+    });
+
+    await model.saveStepParams();
+
+    expect(save).toHaveBeenCalledWith(model, { onlyStepParams: true });
+    expect(updateRoute).toHaveBeenCalledWith(1, {
+      options: {
+        hasPersistedMenuInstanceFlow: true,
+      },
+    });
+  });
+
   it('should clear persisted menu linkage rules when no persisted state remains', async () => {
     const saveModel = vi.spyOn(engine, 'saveModel').mockResolvedValue(undefined as any);
     const destroy = vi.fn().mockResolvedValue(true);

package/src/flow/admin-shell/admin-layout/resolveAdminRouteRuntimeTarget.test.ts

@@ -23,6 +23,17 @@ const app = {
   },
 } as any;
 
+// These fixtures mount the modern client under the `v2` segment; tell the
+// runtime-prefix helper so `isV2AdminRuntime` detects it (the server injects
+// this in production).
+beforeAll(() => {
+  (window as any).__nocobase_modern_client_prefix__ = 'v2';
+});
+
+afterAll(() => {
+  delete (window as any).__nocobase_modern_client_prefix__;
+});
+
 describe('resolveAdminRouteRuntimeTarget', () => {
   it('should resolve flowPage to v2 spa runtime target', () => {
     expect(

package/src/flow/admin-shell/admin-layout/resolveAdminRouteRuntimeTarget.ts

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { getV2EffectiveBasePath } from '../../../authRedirect';
+import { getModernClientPrefix, getV2EffectiveBasePath } from '../../../authRedirect';
 import type { BaseApplication } from '../../../BaseApplication';
 import { NocoBaseDesktopRouteType, type NocoBaseDesktopRoute } from '../../../flow-compat';
 
@@ -26,8 +26,6 @@ export type AdminRouteRuntimeTarget = {
   reason: AdminRouteRuntimeTargetReason;
 };
 
-const V2_PUBLIC_PATH_SUFFIX = '/v2/';
-
 type LocationLike = {
   pathname: string;
   search?: string;
@@ -69,7 +67,7 @@ function normalizePublicPath(value = '/') {
 }
 
 export function isV2AdminRuntime(app?: ResolveAdminRouteRuntimeTargetOptions['app']) {
-  return !!app?.getPublicPath && normalizePublicPath(app.getPublicPath()).endsWith(V2_PUBLIC_PATH_SUFFIX);
+  return !!app?.getPublicPath && normalizePublicPath(app.getPublicPath()).endsWith(`/${getModernClientPrefix()}/`);
 }
 
 export function toRouterNavigationPath(pathname: string, basename?: string) {

package/src/flow/common/Markdown/Edit.tsx

@@ -34,13 +34,41 @@ const defaultToolbar = [
   'code',
   'inline-code',
   'upload',
-  'fullscreen',
 ];
 
 const NAMESPACE = 'block-markdown';
 
 const locales = ['en_US', 'fr_FR', 'pt_BR', 'ja_JP', 'ko_KR', 'ru_RU', 'sv_SE', 'zh_CN', 'zh_TW'];
 
+type MarkdownToolbarItem =
+  | string
+  | {
+      name: string;
+      tipPosition?: string;
+      toolbar?: MarkdownToolbarItem[];
+      [key: string]: unknown;
+    };
+
+function placeToolbarTooltipsBelow(toolbar: MarkdownToolbarItem[]) {
+  return toolbar.map((item) => {
+    if (typeof item === 'string') {
+      if (item === '|' || item === 'br') {
+        return item;
+      }
+      return {
+        name: item,
+        tipPosition: 's',
+      };
+    }
+
+    return {
+      ...item,
+      tipPosition: 's',
+      toolbar: item.toolbar ? placeToolbarTooltipsBelow(item.toolbar) : item.toolbar,
+    };
+  });
+}
+
 const Edit = (props) => {
   const { disabled, onChange, value, fileCollection, toolbar, vditorRef } = props;
   const flowCtx = useFlowContext();
@@ -73,7 +101,7 @@ const Edit = (props) => {
   useEffect(() => {
     if (!containerRef.current) return;
 
-    const toolbarConfig = toolbar ?? defaultToolbar;
+    const toolbarConfig = placeToolbarTooltipsBelow(toolbar ?? defaultToolbar);
     const vditor = new Vditor(containerRef.current, {
       value: value ?? '',
       lang,
@@ -321,7 +349,7 @@ export const MarkdownWithContextSelector: React.FC<MarkdownWithContextSelectorPr
     if (quoteFlag !== false) {
       setInnerValue(value);
     }
-  }, [value]);
+  }, [quoteFlag, value]);
   const handleTextChange = useCallback(
     (e) => {
       const val = e ?? '';
@@ -375,7 +403,7 @@ export const MarkdownWithContextSelector: React.FC<MarkdownWithContextSelectorPr
         editor.focus();
       });
     },
-    [innerValue, onChange],
+    [onChange],
   );
 
   const handleVariableSelected = useCallback(

package/src/flow/components/ConditionBuilder.tsx

@@ -13,14 +13,24 @@ import { FilterGroup, LinkageFilterItem } from './filter';
 import { evaluateConditions, FilterGroupType, removeInvalidFilterItems } from '@nocobase/utils/client';
 
 export const ConditionBuilder = observer(
-  (props: { value: FilterGroupType; onChange: (value: FilterGroupType) => void; extraMetaTree?: MetaTreeNode[] }) => {
+  (props: {
+    value: FilterGroupType;
+    onChange: (value: FilterGroupType) => void;
+    extraMetaTree?: MetaTreeNode[];
+    maxAssociationFieldDepth?: number;
+  }) => {
     const ctx = useFlowContext();
 
     return (
       <FilterGroup
         value={props.value || { logic: '$and', items: [] }}
         FilterItem={(itemProps) => (
-          <LinkageFilterItem model={ctx.model} value={itemProps.value} extraMetaTree={props.extraMetaTree} />
+          <LinkageFilterItem
+            model={ctx.model}
+            value={itemProps.value}
+            extraMetaTree={props.extraMetaTree}
+            maxAssociationFieldDepth={props.maxAssociationFieldDepth}
+          />
         )}
         onChange={props.onChange}
       />