@nocobase/client-v2 2.1.0-beta.26 → 2.1.0-beta.27

package/src/flow/components/code-editor/runjsDiagnostics.ts

@@ -27,6 +27,50 @@ import {
   shouldPreprocessRunJSTemplates,
 } from '@nocobase/flow-engine';
 
+const acornWalkBase = {
+  ...(acornWalk as any).base,
+  JSXElement(node: any, state: any, callback: any) {
+    callback(node.openingElement, state);
+    for (const child of node.children || []) callback(child, state);
+    if (node.closingElement) callback(node.closingElement, state);
+  },
+  JSXFragment(node: any, state: any, callback: any) {
+    callback(node.openingFragment, state);
+    for (const child of node.children || []) callback(child, state);
+    callback(node.closingFragment, state);
+  },
+  JSXOpeningElement(node: any, state: any, callback: any) {
+    callback(node.name, state);
+    for (const attribute of node.attributes || []) callback(attribute, state);
+  },
+  JSXClosingElement(node: any, state: any, callback: any) {
+    callback(node.name, state);
+  },
+  JSXAttribute(node: any, state: any, callback: any) {
+    callback(node.name, state);
+    if (node.value) callback(node.value, state);
+  },
+  JSXExpressionContainer(node: any, state: any, callback: any) {
+    callback(node.expression, state);
+  },
+  JSXSpreadAttribute(node: any, state: any, callback: any) {
+    callback(node.argument, state);
+  },
+  JSXMemberExpression(node: any, state: any, callback: any) {
+    callback(node.object, state);
+    callback(node.property, state);
+  },
+  JSXNamespacedName(node: any, state: any, callback: any) {
+    callback(node.namespace, state);
+    callback(node.name, state);
+  },
+  JSXIdentifier() {},
+  JSXText() {},
+  JSXEmptyExpression() {},
+  JSXOpeningFragment() {},
+  JSXClosingFragment() {},
+};
+
 export type RunJSIssue = {
   type: 'lint' | 'runtime';
   message: string;
@@ -615,55 +659,63 @@ function collectHeuristicIssues(code: string): RunJSIssue[] {
 
   // Collect declared identifiers (very coarse, best-effort).
   try {
-    acornWalk.full(ast, (node: any) => {
-      switch (node?.type) {
-        case 'VariableDeclarator':
-          addPatternIds(node.id);
-          break;
-        case 'FunctionDeclaration':
-          addId(node.id);
-          (node.params || []).forEach(addPatternIds);
-          break;
-        case 'FunctionExpression':
-          addId(node.id);
-          (node.params || []).forEach(addPatternIds);
-          break;
-        case 'ArrowFunctionExpression':
-          (node.params || []).forEach(addPatternIds);
-          break;
-        case 'CatchClause':
-          addPatternIds((node as any).param);
-          break;
-        case 'ClassDeclaration':
-          addId(node.id);
-          break;
-        default:
-          break;
-      }
-    });
+    acornWalk.full(
+      ast,
+      (node: any) => {
+        switch (node?.type) {
+          case 'VariableDeclarator':
+            addPatternIds(node.id);
+            break;
+          case 'FunctionDeclaration':
+            addId(node.id);
+            (node.params || []).forEach(addPatternIds);
+            break;
+          case 'FunctionExpression':
+            addId(node.id);
+            (node.params || []).forEach(addPatternIds);
+            break;
+          case 'ArrowFunctionExpression':
+            (node.params || []).forEach(addPatternIds);
+            break;
+          case 'CatchClause':
+            addPatternIds((node as any).param);
+            break;
+          case 'ClassDeclaration':
+            addId(node.id);
+            break;
+          default:
+            break;
+        }
+      },
+      acornWalkBase,
+    );
   } catch (_) {
     // ignore
   }
 
   // 1) Non-callable call: 123(), 'x'(), (1+2)(), ({})()
   try {
-    acornWalk.full(ast, (node: any) => {
-      if (!node || typeof node.type !== 'string') return;
-      if (node.type !== 'CallExpression') return;
-      const callee = node.callee;
-      const isCallableLike =
-        callee &&
-        (callee.type === 'Identifier' ||
-          callee.type === 'MemberExpression' ||
-          callee.type === 'FunctionExpression' ||
-          callee.type === 'ArrowFunctionExpression' ||
-          callee.type === 'CallExpression' ||
-          callee.type === 'ChainExpression');
-      if (!isCallableLike) {
-        const pos = (callee as any)?.start ?? node.start ?? 0;
-        pushAtPos(pos, 'no-noncallable-call', 'This expression is not callable.');
-      }
-    });
+    acornWalk.full(
+      ast,
+      (node: any) => {
+        if (!node || typeof node.type !== 'string') return;
+        if (node.type !== 'CallExpression') return;
+        const callee = node.callee;
+        const isCallableLike =
+          callee &&
+          (callee.type === 'Identifier' ||
+            callee.type === 'MemberExpression' ||
+            callee.type === 'FunctionExpression' ||
+            callee.type === 'ArrowFunctionExpression' ||
+            callee.type === 'CallExpression' ||
+            callee.type === 'ChainExpression');
+        if (!isCallableLike) {
+          const pos = (callee as any)?.start ?? node.start ?? 0;
+          pushAtPos(pos, 'no-noncallable-call', 'This expression is not callable.');
+        }
+      },
+      acornWalkBase,
+    );
   } catch (_) {
     // ignore
   }
@@ -673,37 +725,45 @@ function collectHeuristicIssues(code: string): RunJSIssue[] {
   try {
     const reported = new Set<string>();
     const allowedShort = new Set<string>(['t']);
-    acornWalk.full(ast, (node: any) => {
-      if (!node || typeof node.type !== 'string') return;
-      if (node.type !== 'CallExpression') return;
-      let callee = node.callee;
-      if (callee?.type === 'ChainExpression') callee = callee.expression;
-      if (!callee || callee.type !== 'MemberExpression') return;
-      const obj = callee.object;
-      if (!obj || obj.type !== 'Identifier' || obj.name !== 'ctx') return;
-
-      let name: string | null = null;
-      if (!callee.computed && callee.property?.type === 'Identifier') {
-        name = callee.property.name;
-      } else if (callee.computed && callee.property?.type === 'Literal' && typeof callee.property.value === 'string') {
-        name = callee.property.value;
-      }
+    acornWalk.full(
+      ast,
+      (node: any) => {
+        if (!node || typeof node.type !== 'string') return;
+        if (node.type !== 'CallExpression') return;
+        let callee = node.callee;
+        if (callee?.type === 'ChainExpression') callee = callee.expression;
+        if (!callee || callee.type !== 'MemberExpression') return;
+        const obj = callee.object;
+        if (!obj || obj.type !== 'Identifier' || obj.name !== 'ctx') return;
+
+        let name: string | null = null;
+        if (!callee.computed && callee.property?.type === 'Identifier') {
+          name = callee.property.name;
+        } else if (
+          callee.computed &&
+          callee.property?.type === 'Literal' &&
+          typeof callee.property.value === 'string'
+        ) {
+          name = callee.property.value;
+        }
 
-      if (!name || typeof name !== 'string') return;
-      const normalized = name.trim();
-      if (!normalized || normalized.startsWith('_')) return;
-      if (normalized.length > 2) return;
-      if (allowedShort.has(normalized)) return;
-      if (reported.has(normalized)) return;
-
-      const pos = (callee.property as any)?.start ?? callee.start ?? node.start ?? 0;
-      pushAtPos(
-        pos,
-        'possible-undefined-ctx-member-call',
-        `Possible undefined ctx method call: ctx.${normalized}(). This may be a typo or not available in the current ctx API.`,
-      );
-      reported.add(normalized);
-    });
+        if (!name || typeof name !== 'string') return;
+        const normalized = name.trim();
+        if (!normalized || normalized.startsWith('_')) return;
+        if (normalized.length > 2) return;
+        if (allowedShort.has(normalized)) return;
+        if (reported.has(normalized)) return;
+
+        const pos = (callee.property as any)?.start ?? callee.start ?? node.start ?? 0;
+        pushAtPos(
+          pos,
+          'possible-undefined-ctx-member-call',
+          `Possible undefined ctx method call: ctx.${normalized}(). This may be a typo or not available in the current ctx API.`,
+        );
+        reported.add(normalized);
+      },
+      acornWalkBase,
+    );
   } catch (_) {
     // ignore
   }
@@ -711,31 +771,35 @@ function collectHeuristicIssues(code: string): RunJSIssue[] {
   // 2) Possible undefined variable (exclude declarations and property keys)
   try {
     const reported = new Set<string>();
-    acornWalk.ancestor(ast, {
-      Identifier(node: any, ancestors: any[]) {
-        const name = node?.name;
-        if (!name || declared.has(name) || reported.has(name)) return;
-        const parent = ancestors[ancestors.length - 2];
-        if (!parent) return;
-        if (
-          (parent.type === 'VariableDeclarator' && parent.id === node) ||
-          (parent.type === 'FunctionDeclaration' && parent.id === node) ||
-          (parent.type === 'FunctionExpression' && parent.id === node) ||
-          (parent.type === 'ClassDeclaration' && parent.id === node) ||
-          (parent.type === 'ClassExpression' && parent.id === node) ||
-          (parent.type === 'Property' && parent.key === node && parent.computed !== true) ||
-          (parent.type === 'MemberExpression' && parent.property === node && parent.computed !== true) ||
-          (parent.type === 'LabeledStatement' && parent.label === node) ||
-          (parent.type === 'BreakStatement' && parent.label === node) ||
-          (parent.type === 'ContinueStatement' && parent.label === node)
-        ) {
-          return;
-        }
-        const pos = (node as any).start ?? 0;
-        pushAtPos(pos, 'possible-undefined-variable', `Possible undefined variable: ${name}`);
-        reported.add(name);
+    acornWalk.ancestor(
+      ast,
+      {
+        Identifier(node: any, ancestors: any[]) {
+          const name = node?.name;
+          if (!name || declared.has(name) || reported.has(name)) return;
+          const parent = ancestors[ancestors.length - 2];
+          if (!parent) return;
+          if (
+            (parent.type === 'VariableDeclarator' && parent.id === node) ||
+            (parent.type === 'FunctionDeclaration' && parent.id === node) ||
+            (parent.type === 'FunctionExpression' && parent.id === node) ||
+            (parent.type === 'ClassDeclaration' && parent.id === node) ||
+            (parent.type === 'ClassExpression' && parent.id === node) ||
+            (parent.type === 'Property' && parent.key === node && parent.computed !== true) ||
+            (parent.type === 'MemberExpression' && parent.property === node && parent.computed !== true) ||
+            (parent.type === 'LabeledStatement' && parent.label === node) ||
+            (parent.type === 'BreakStatement' && parent.label === node) ||
+            (parent.type === 'ContinueStatement' && parent.label === node)
+          ) {
+            return;
+          }
+          const pos = (node as any).start ?? 0;
+          pushAtPos(pos, 'possible-undefined-variable', `Possible undefined variable: ${name}`);
+          reported.add(name);
+        },
       },
-    });
+      acornWalkBase,
+    );
   } catch (_) {
     // ignore
   }

package/src/flow/components/code-editor/types.ts

@@ -17,6 +17,7 @@ import { RunLog } from './hooks/useCodeRunner';
 export interface EditorRef {
   write(document: string): void;
   read(): string;
+  run?(): Promise<unknown>;
   buttonGroupHeight?: number;
   snippetEntries: SnippetEntry[];
   logs: RunLog[];

package/src/flow/components/filter/LinkageFilterItem.tsx

@@ -8,7 +8,7 @@
  */
 
 import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { lazy } from '../../../flow-compat';
+import { getFlowFieldInterfaceOptions, lazy } from '../../../flow-compat';
 import { Input, InputNumber, Select, Space, Switch } from 'antd';
 import merge from 'lodash/merge';
 import uniqBy from 'lodash/uniqBy';
@@ -227,11 +227,12 @@ export const LinkageFilterItem: React.FC<LinkageFilterItemProps> = observer((pro
 
   const operatorMetadataList: OperatorMeta[] = useMemo(() => {
     if (leftFieldMeta) {
-      const dataSourceManager = model.context.app.dataSourceManager;
       const fieldInterface = leftFieldMeta.interface
-        ? (dataSourceManager.collectionFieldInterfaceManager.getFieldInterface(
+        ? (getFlowFieldInterfaceOptions(
             leftFieldMeta.interface,
-          ) as FieldInterfaceDef)
+            model.context.dataSourceManager,
+            model.context.app?.dataSourceManager,
+          ) as FieldInterfaceDef | undefined)
         : undefined;
       const schemaOperators = (leftFieldMeta as any)?.uiSchema?.['x-filter-operators'] as
         | Array<OperatorMeta & { visible?: (meta: MetaTreeNode) => boolean }>
@@ -392,7 +393,7 @@ export const LinkageFilterItem: React.FC<LinkageFilterItemProps> = observer((pro
     const base = Array.isArray(tree) ? tree : [];
     const merged = mergeExtraMetaTreeWithBase(base, extraMetaTree);
     const getFieldInterface = (name: string) =>
-      model.context.app?.dataSourceManager?.collectionFieldInterfaceManager?.getFieldInterface?.(name) as
+      getFlowFieldInterfaceOptions(name, model.context.dataSourceManager, model.context.app?.dataSourceManager) as
         | FieldInterfaceDef
         | undefined;
     return await enhanceMetaTreeWithFilterableChildren(merged, getFieldInterface);

package/src/flow/components/filter/VariableFilterItem.tsx

@@ -9,7 +9,7 @@
 
 import React, { useState, useMemo, useCallback, useEffect } from 'react';
 import { Cascader, Checkbox, Input, InputNumber, Radio, Select, Space, Switch } from 'antd';
-import { lazy } from '../../../flow-compat';
+import { getFlowFieldInterfaceOptions, lazy } from '../../../flow-compat';
 import merge from 'lodash/merge';
 import type { ISchema } from '@formily/json-schema';
 import {
@@ -286,18 +286,24 @@ export const VariableFilterItem: React.FC<VariableFilterItemProps> = observer(
         children?: Array<{ name: string; title?: string; schema?: ISchema; operators?: OperatorMeta[] }>;
       };
     };
+    const getFieldInterface = useCallback(
+      (interfaceName: string | undefined) =>
+        getFlowFieldInterfaceOptions(
+          interfaceName,
+          model.context.dataSourceManager,
+          model.context.app?.dataSourceManager,
+        ) as FieldInterfaceDef | undefined,
+      [model],
+    );
 
     // 基于字段接口的动态操作符元数据（优先使用子菜单 schema 中自定义的 operators，其次再用接口默认 operators）
     const operatorMetaList: OperatorMeta[] = useMemo(() => {
       if (!leftMeta) return [];
-      const dm = model.context.app?.dataSourceManager;
-      const fi = leftMeta.interface
-        ? (dm?.collectionFieldInterfaceManager?.getFieldInterface(leftMeta.interface) as FieldInterfaceDef | undefined)
-        : undefined;
+      const fi = leftMeta.interface ? getFieldInterface(leftMeta.interface) : undefined;
       const schemaOps: OperatorMeta[] | undefined = (leftMeta as any)?.uiSchema?.['x-filter-operators'];
       const baseOps = (Array.isArray(schemaOps) && schemaOps.length ? schemaOps : fi?.filterable?.operators) || [];
       return baseOps.filter((op) => !op.visible || op.visible(leftMeta));
-    }, [leftMeta, model]);
+    }, [getFieldInterface, leftMeta]);
 
     useEffect(() => {
       if (!operatorMetaList.length) return;
@@ -578,16 +584,11 @@ export const VariableFilterItem: React.FC<VariableFilterItemProps> = observer(
     const enhancedMetaTree = useMemo(() => {
       type MetaTreeProvider = () => MetaTreeNode[] | Promise<MetaTreeNode[]>;
       return async () => {
-        const dm = model.context.app?.dataSourceManager;
-        const fiMgr = dm?.collectionFieldInterfaceManager;
-
         // 优先复用已注入 meta；否则在本组件范围内临时构建
         const nodes: MetaTreeNode[] = await buildCollectionLeftMetaTreeLocal(model.context);
 
         const enhanceNode = async (node: MetaTreeNode): Promise<MetaTreeNode> => {
-          const fi = node.interface
-            ? (fiMgr?.getFieldInterface(node.interface) as FieldInterfaceDef | undefined)
-            : undefined;
+          const fi = node.interface ? getFieldInterface(node.interface) : undefined;
           const extraChildren: MetaTreeNode[] = [];
           const filterable = fi?.filterable;
           const childrenDefs = filterable?.children as
@@ -634,7 +635,7 @@ export const VariableFilterItem: React.FC<VariableFilterItemProps> = observer(
         }
         return out;
       };
-    }, [model]);
+    }, [getFieldInterface, model]);
 
     return (
       <Space wrap style={{ width: '100%' }}>

package/src/flow/components/filter/__tests__/LinkageFilterItem.test.tsx

@@ -110,6 +110,39 @@ describe('LinkageFilterItem', () => {
     expect(screen.queryByText('[object Object]')).toBeNull();
   });
 
+  it('uses scoped context dataSourceManager when app dataSourceManager has no field interface manager', async () => {
+    const value = observable({ path: '', operator: '', value: '' }) as any;
+    const { model, app } = createModel();
+    const getRuntimeFieldInterface = vi.fn((name: string) => ({
+      name,
+      filterable: {
+        operators: [{ value: '$eq', label: 'Equals', selected: true }],
+      },
+    }));
+    model.context.dataSourceManager.setCollectionFieldInterfaceManager({
+      getFieldInterface: getRuntimeFieldInterface,
+    });
+    (app as any).dataSourceManager = {};
+
+    (globalThis as any).__TEST_PATH__ = 'assignee';
+    (globalThis as any).__TEST_META__ = {
+      interface: 'belongsTo',
+      uiSchema: { 'x-component': 'RecordPicker' },
+      paths: ['collection', 'assignee'],
+      name: 'assignee',
+      title: 'Assignee',
+      type: 'object',
+    };
+
+    render(<LinkageFilterItem value={value} model={model} />);
+    fireEvent.click(screen.getByTestId('variable-input'));
+
+    await waitFor(() => {
+      expect(value.operator).toBe('$eq');
+      expect(getRuntimeFieldInterface).toHaveBeenCalledWith('belongsTo');
+    });
+  });
+
   it('renders operator schema component for multi-keyword constants', async () => {
     const value = observable({ path: '', operator: '', value: 'foo\nbar' }) as any;
     const { model, app } = createModel();

package/src/flow/components/filter/__tests__/VariableFilterItem.test.tsx

@@ -121,6 +121,8 @@ describe('VariableFilterItem', () => {
     // Ensure document body for antd portals if needed
     document.body.innerHTML = '';
     delete (globalThis as any).__LAST_VARIABLE_INPUT_PROPS__;
+    delete (globalThis as any).__TEST_PATH__;
+    delete (globalThis as any).__TEST_META__;
   });
 
   it('returns undefined path for empty left value in converter', () => {
@@ -153,9 +155,53 @@ describe('VariableFilterItem', () => {
     expect(value.value).toBe('abc');
   });
 
+  it('uses scoped context dataSourceManager when app dataSourceManager has no field interface manager', async () => {
+    const value = observable({ path: '', operator: '', value: '' }) as any;
+    const model = CreateModel();
+    const getRuntimeFieldInterface = vi.fn((name: string) => ({
+      name,
+      filterable: {
+        operators: [{ value: '$eq', label: 'Equals' }],
+        children: [
+          {
+            name: 'runtimeChild',
+            title: 'Runtime child',
+            schema: { 'x-component': 'Input' },
+            operators: [{ value: '$includes', label: 'contains' }],
+          },
+        ],
+      },
+    }));
+
+    model.context.dataSourceManager.setCollectionFieldInterfaceManager({
+      getFieldInterface: getRuntimeFieldInterface,
+    });
+    (model.context.app as any).dataSourceManager = {};
+    (globalThis as any).__TEST_PATH__ = 'assignee';
+    (globalThis as any).__TEST_META__ = {
+      interface: 'belongsTo',
+      uiSchema: { 'x-component': 'RecordPicker' },
+      paths: ['collection', 'assignee'],
+      name: 'assignee',
+      title: 'Assignee',
+      type: 'object',
+    };
+
+    render(<VariableFilterItem value={value} model={model} rightAsVariable={false} />);
+    const leftVariableInputProps = (globalThis as any).__LAST_VARIABLE_INPUT_PROPS__;
+    const metaTree = await leftVariableInputProps.metaTree();
+    const nameNode = metaTree.find((node: any) => node.name === 'name');
+    expect(nameNode?.children?.some((child: any) => child.name === 'runtimeChild')).toBe(true);
+
+    fireEvent.click(screen.getByTestId('variable-input'));
+
+    await waitFor(() => {
+      expect(value.operator).toBe('$eq');
+      expect(getRuntimeFieldInterface).toHaveBeenCalledWith('belongsTo');
+    });
+  });
+
   it('keeps numeric string when x-component uses InputNumber with stringMode', async () => {
-    const prevMeta = (globalThis as any).__TEST_META__;
-    const prevPath = (globalThis as any).__TEST_PATH__;
     (globalThis as any).__TEST_PATH__ = 'price';
     (globalThis as any).__TEST_META__ = {
       interface: 'input',
@@ -177,9 +223,6 @@ describe('VariableFilterItem', () => {
       expect(input.value).toBe('123.45');
       expect(value.value).toBe('123.45');
     });
-
-    (globalThis as any).__TEST_META__ = prevMeta;
-    (globalThis as any).__TEST_PATH__ = prevPath;
   });
 
   it('normalizes synthetic event value when formula field renders Input from app components', async () => {

package/src/flow/internal/utils/__tests__/titleFieldQuickSync.test.ts

@@ -26,6 +26,7 @@ describe('titleFieldQuickSync', () => {
     expect(isTitleUsableField(dm, { interface: 'formula' } as any)).toBe(false);
     expect(isTitleUsableField(dm, { interface: 'unknown' } as any)).toBe(false);
     expect(isTitleUsableField(undefined, { interface: 'input' } as any)).toBe(false);
+    expect(isTitleUsableField({} as any, { interface: 'input' } as any)).toBe(false);
   });
 
   it('syncs title field to main data source collection', async () => {

package/src/flow/internal/utils/titleFieldQuickSync.ts

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { DataSourceManager } from '@nocobase/flow-engine';
+import { DataSourceManager, getCollectionFieldInterface } from '@nocobase/flow-engine';
 import type { CollectionFieldOptions } from '../../../flow-compat';
 import { DEFAULT_DATA_SOURCE_KEY } from '../../../flow-compat';
 
@@ -33,7 +33,7 @@ export function isTitleUsableField(
 ): boolean {
   const ifaceName = typeof field?.interface === 'string' ? field.interface : undefined;
   if (!dm || !ifaceName) return false;
-  return !!dm.collectionFieldInterfaceManager.getFieldInterface(ifaceName)?.titleUsable;
+  return !!getCollectionFieldInterface(ifaceName, dm)?.titleUsable;
 }
 
 function resolveDataSourceKey(targetCollection: CollectionLike | null | undefined): string {

package/src/flow/models/actions/FilterActionModel.tsx

@@ -8,6 +8,7 @@
  */
 
 import { tExpr, MobilePopup, MultiRecordResource, useFlowSettingsContext } from '@nocobase/flow-engine';
+import type { CollectionFieldInterfaceDataSourceManager } from '@nocobase/flow-engine';
 import { isEmptyFilter, transformFilter } from '@nocobase/utils/client';
 import { ButtonProps, Popover, Transfer } from 'antd';
 import React from 'react';
@@ -15,6 +16,7 @@ import { FilterGroup, VariableFilterItem } from '../../components/filter';
 import { ActionModel, CollectionBlockModel } from '../base';
 import { FilterContainer } from '../../components/filter/FilterContainer';
 import _ from 'lodash';
+import { getFlowFieldInterfaceOptions } from '../../../flow-compat';
 
 export class FilterActionModel extends ActionModel {
   static scene = 'collection';
@@ -135,9 +137,11 @@ FilterActionModel.registerFlow({
           'x-component': (props) => {
             // eslint-disable-next-line react-hooks/rules-of-hooks
             const { model } = useFlowSettingsContext();
-            const dm = model?.context?.app?.dataSourceManager;
-            const fiMgr = dm?.collectionFieldInterfaceManager;
-            const filterable = getFilterableFields(model.context.blockModel.collection, fiMgr);
+            const filterable = getFilterableFields(
+              model.context.blockModel.collection,
+              model.context.dataSourceManager,
+              model.context.app?.dataSourceManager,
+            );
             const dataSource = filterable.map((field: any) => ({ key: field.name, title: field.title }));
             return (
               <Transfer
@@ -157,9 +161,11 @@ FilterActionModel.registerFlow({
       },
       defaultParams(ctx) {
         // 默认仅包含“可筛选”的字段（与 1.0 一致），以避免 JSON 等未提供 operators 的字段出现在默认允许集合中
-        const dm = ctx?.model?.context?.app?.dataSourceManager;
-        const fiMgr = dm?.collectionFieldInterfaceManager;
-        const names = getFilterableFields(ctx.blockModel.collection, fiMgr).map((field: any) => field.name);
+        const names = getFilterableFields(
+          ctx.blockModel.collection,
+          ctx.model?.context?.dataSourceManager,
+          ctx.model?.context?.app?.dataSourceManager,
+        ).map((field: any) => field.name);
         return {
           filterableFieldNames: names || [],
         };
@@ -304,13 +310,15 @@ FilterActionModel.registerFlow({
   },
 });
 
-function getFilterableFields(collection: any, fiMgr: any) {
+function getFilterableFields(
+  collection: any,
+  ...dataSourceManagers: Array<CollectionFieldInterfaceDataSourceManager | null | undefined>
+) {
   const fields = collection?.getFields?.() || [];
-  if (!fiMgr) return [];
   return fields.filter((field: any) => {
     if (!field?.interface) return false;
     if (field?.filterable === false) return false;
-    const fi = fiMgr.getFieldInterface(field.interface);
+    const fi = getFlowFieldInterfaceOptions(field.interface, ...dataSourceManagers);
     return !!fi?.filterable;
   });
 }