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

package/src/flow/models/blocks/filter-form/fields/FieldComponentProps.tsx

@@ -14,7 +14,11 @@ import { Input, Radio, Checkbox, Space, Button, Select } from 'antd';
 import { PlusOutlined, CloseOutlined } from '@ant-design/icons';
 import { useTranslation } from 'react-i18next';
 import { FilterableItemModel, useFlowContext, useFlowEngine } from '@nocobase/flow-engine';
-import { isTitleField } from '../../../../../flow-compat';
+import {
+  getFlowFieldInterfaceOptions,
+  hasFlowFieldInterfaceLookup,
+  isTitleFieldInterface,
+} from '../../../../../flow-compat';
 
 const RECORD_SELECT_DATA_SOURCE_KEY = 'recordSelectDataSourceKey';
 const RECORD_SELECT_COLLECTION_KEY = 'recordSelectTargetCollection';
@@ -36,7 +40,12 @@ export const FieldComponentProps: React.FC<{ fieldModel: string; source: string[
   const resolvedFieldModel = fieldModel || propsValue?.fieldModel;
   const flowEngine = useFlowEngine();
   const ctx = useFlowContext();
-  const appDataSourceManager = ctx?.app?.dataSourceManager;
+  const dataSourceManager = ctx?.dataSourceManager || flowEngine?.dataSourceManager || ctx?.app?.dataSourceManager;
+  const hasFieldInterfaceLookup = hasFlowFieldInterfaceLookup(dataSourceManager);
+  const getFieldInterface = useCallback(
+    (interfaceName: string | undefined) => getFlowFieldInterfaceOptions(interfaceName, dataSourceManager),
+    [dataSourceManager],
+  );
 
   const getCurrentValue = () => field.value || {};
   const updateProps = (key: string, value: any) => {
@@ -165,15 +174,20 @@ export const FieldComponentProps: React.FC<{ fieldModel: string; source: string[
   }, [activeDataSource, translateLabel]);
   const titleFieldOptions = useMemo(() => {
     if (!activeCollection?.getFields) return [];
-    const shouldKeep = (fieldItem: any) =>
-      appDataSourceManager ? isTitleField(appDataSourceManager, fieldItem.options) : true;
+    const shouldKeep = (fieldItem: any) => {
+      if (!hasFieldInterfaceLookup) {
+        return true;
+      }
+      const fieldOptions = fieldItem?.options || fieldItem;
+      return isTitleFieldInterface(getFieldInterface(fieldOptions?.interface));
+    };
     return (activeCollection.getFields() || [])
       .filter((fieldItem: any) => shouldKeep(fieldItem))
       .map((fieldItem: any) => ({
         label: translateLabel(fieldItem.options?.uiSchema?.title) || translateLabel(fieldItem.title) || fieldItem.name,
         value: fieldItem.name,
       }));
-  }, [activeCollection, appDataSourceManager, translateLabel]);
+  }, [activeCollection, getFieldInterface, hasFieldInterfaceLookup, translateLabel]);
   const valueFieldOptions = useMemo(() => {
     if (!activeCollection?.getFields) return [];
     const shouldKeep = (fieldItem: any) => {
@@ -182,8 +196,8 @@ export const FieldComponentProps: React.FC<{ fieldModel: string; source: string[
       if (fieldOptions.filterable === false || !interfaceName) {
         return false;
       }
-      if (appDataSourceManager) {
-        const fieldInterface = appDataSourceManager.collectionFieldInterfaceManager?.getFieldInterface?.(interfaceName);
+      if (hasFieldInterfaceLookup) {
+        const fieldInterface = getFieldInterface(interfaceName);
         if (!fieldInterface?.filterable) {
           return false;
         }
@@ -197,7 +211,7 @@ export const FieldComponentProps: React.FC<{ fieldModel: string; source: string[
         label: translateLabel(fieldItem.options?.uiSchema?.title) || translateLabel(fieldItem.title) || fieldItem.name,
         value: fieldItem.name,
       }));
-  }, [activeCollection, appDataSourceManager, translateLabel]);
+  }, [activeCollection, getFieldInterface, hasFieldInterfaceLookup, translateLabel]);
 
   useEffect(() => {
     if (resolvedFieldModel !== 'FilterFormCustomRecordSelectFieldModel') return;

package/src/flow/models/blocks/filter-form/fields/__tests__/FilterFormCustomFieldModel.recordSelect.test.tsx

@@ -222,6 +222,17 @@ describe('FilterForm custom field record select', () => {
   it('hides association fields from value field options', async () => {
     const engine = new FlowEngine();
     engine.registerModels({ HostModel, FilterFormCustomRecordSelectFieldModel });
+    engine.dataSourceManager.setCollectionFieldInterfaceManager({
+      getFieldInterface: vi.fn((name: string) => {
+        if (['input', 'number'].includes(name)) {
+          return { titleUsable: true, filterable: { operators: [] } };
+        }
+        if (name === 'm2m') {
+          return { filterable: { operators: [] } };
+        }
+        return undefined;
+      }),
+    });
 
     const ds = engine.dataSourceManager.getDataSource('main');
     ds?.addCollection({
@@ -242,6 +253,12 @@ describe('FilterForm custom field record select', () => {
           title: 'Hidden text',
           filterable: false,
         },
+        {
+          name: 'jsonPayload',
+          type: 'json',
+          interface: 'json',
+          title: 'JSON payload',
+        },
         {
           name: 'roles',
           type: 'belongsToMany',
@@ -298,6 +315,7 @@ describe('FilterForm custom field record select', () => {
       );
       expect(optionTexts).toContain('nickname');
       expect(optionTexts).not.toContain('Hidden text');
+      expect(optionTexts).not.toContain('JSON payload');
       expect(optionTexts).not.toContain('Roles relation');
     });
   });

package/src/flow/models/blocks/filter-manager/FilterManager.ts

@@ -10,6 +10,7 @@
 import { FilterGroup, FilterItem, FlowModel } from '@nocobase/flow-engine';
 import _ from 'lodash';
 import { CollectionBlockModel } from '../../base/CollectionBlockModel';
+import { isArrayLikeField } from '../shared/filterOperators';
 import { getDefaultOperator, isFilterValueEmpty } from './utils';
 
 type FilterConfig = {
@@ -23,6 +24,13 @@ type FilterConfig = {
   operator?: string;
 };
 
+const ARRAY_FIELD_OPERATORS_TO_SCALAR_OPERATORS: Record<string, string> = {
+  $match: '$in',
+  $anyOf: '$in',
+  $notMatch: '$notIn',
+  $noneOf: '$notIn',
+};
+
 export type ConnectFieldsConfig = {
   targets: {
     /** 数据区块或者图表区块的 model uid */
@@ -32,6 +40,44 @@ export type ConnectFieldsConfig = {
   }[];
 };
 
+function getTargetField(targetModel: any, fieldPath: string) {
+  const dataSourceManager = targetModel?.context?.dataSourceManager;
+  const collection = targetModel?.collection;
+  if (!dataSourceManager || !collection?.dataSourceKey || !collection?.name || !fieldPath) {
+    return;
+  }
+
+  let collectionName = collection.name;
+  const fieldNames = fieldPath.split('.').filter(Boolean);
+  for (let index = 0; index < fieldNames.length; index += 1) {
+    const field = dataSourceManager.getCollectionField?.(
+      `${collection.dataSourceKey}.${collectionName}.${fieldNames[index]}`,
+    );
+    if (!field || index === fieldNames.length - 1) {
+      return field;
+    }
+
+    collectionName = field.target || field.targetCollection?.name;
+    if (!collectionName) {
+      return;
+    }
+  }
+}
+
+function normalizeOperatorForTargetField(operator: string, targetModel: any, fieldPath: string) {
+  const scalarOperator = ARRAY_FIELD_OPERATORS_TO_SCALAR_OPERATORS[operator];
+  if (!scalarOperator) {
+    return operator;
+  }
+
+  const targetField = getTargetField(targetModel, fieldPath);
+  if (!targetField || isArrayLikeField(targetField)) {
+    return operator;
+  }
+
+  return scalarOperator;
+}
+
 export class FilterManager {
   private filterConfigs: FilterConfig[];
   private readonly gridModel: FlowModel;
@@ -300,7 +346,11 @@ export class FilterManager {
       // 构建筛选条件
       const filterConditions = config.filterPaths.map((fieldPath) => ({
         path: fieldPath,
-        operator: config.operator || getDefaultOperator(filterModel),
+        operator: normalizeOperatorForTargetField(
+          config.operator || getDefaultOperator(filterModel),
+          targetModel,
+          fieldPath,
+        ),
         value: filterValue,
       }));
 

package/src/flow/models/blocks/filter-manager/__tests__/FilterManager.test.ts

@@ -496,6 +496,81 @@ describe('FilterManager', () => {
       expect(mockTargetModel2.resource.refresh).toHaveBeenCalledTimes(1);
     });
 
+    it('should normalize array operators when the target field is scalar', async () => {
+      const filterConfigs = [
+        {
+          filterId: 'filter-1',
+          targetId: 'target-scalar',
+          filterPaths: ['status'],
+          operator: '$match',
+        },
+        {
+          filterId: 'filter-1',
+          targetId: 'target-array',
+          filterPaths: ['tags'],
+          operator: '$match',
+        },
+        {
+          filterId: 'filter-1',
+          targetId: 'target-deep-array',
+          filterPaths: ['org.company.tags'],
+          operator: '$match',
+        },
+      ];
+
+      (filterManager as any).filterConfigs = filterConfigs;
+
+      const createTargetModel = (getCollectionField: any) => ({
+        collection: {
+          dataSourceKey: 'main',
+          name: 'users',
+        },
+        context: {
+          dataSourceManager: {
+            getCollectionField,
+          },
+        },
+        resource: {
+          addFilterGroup: vi.fn(),
+          removeFilterGroup: vi.fn(),
+          refresh: vi.fn().mockResolvedValue(undefined),
+        },
+        setFilterActive: vi.fn(),
+        getDataLoadingMode: vi.fn().mockReturnValue('auto'),
+      });
+      const mockScalarTargetModel = createTargetModel(vi.fn().mockReturnValue({ interface: 'select', type: 'string' }));
+      const mockArrayTargetModel = createTargetModel(
+        vi.fn().mockReturnValue({ interface: 'multipleSelect', type: 'array' }),
+      );
+      const mockDeepArrayTargetModel = createTargetModel(
+        vi.fn((key: string) => {
+          const fields = {
+            'main.users.org': { target: 'orgs' },
+            'main.orgs.company': { target: 'companies' },
+            'main.companies.tags': { interface: 'multipleSelect', type: 'array' },
+          };
+          return fields[key];
+        }),
+      );
+      const mockFilterModel = {
+        getFilterValue: vi.fn().mockReturnValue(['a1']),
+      };
+
+      (mockFlowModel.flowEngine.getModel as any).mockImplementation((uid: string) => {
+        if (uid === 'target-scalar') return mockScalarTargetModel;
+        if (uid === 'target-array') return mockArrayTargetModel;
+        if (uid === 'target-deep-array') return mockDeepArrayTargetModel;
+        if (uid === 'filter-1') return mockFilterModel;
+        return null;
+      });
+
+      await filterManager.refreshTargetsByFilter('filter-1');
+
+      expect(mockScalarTargetModel.resource.addFilterGroup.mock.calls[0][1].options.operator).toBe('$in');
+      expect(mockArrayTargetModel.resource.addFilterGroup.mock.calls[0][1].options.operator).toBe('$match');
+      expect(mockDeepArrayTargetModel.resource.addFilterGroup.mock.calls[0][1].options.operator).toBe('$match');
+    });
+
     it('should process multiple filterIds successfully', async () => {
       // Setup filter configs
       const filterConfigs = [

package/src/flow/models/blocks/form/FormItemModel.tsx

@@ -22,6 +22,7 @@ import { FieldModel } from '../../base/FieldModel';
 import { DetailsItemModel } from '../details/DetailsItemModel';
 import { EditFormModel } from './EditFormModel';
 import _ from 'lodash';
+import { Tooltip } from 'antd';
 import { coerceForToOneField } from '../../../internal/utils/associationValueCoercion';
 import { buildDynamicNamePath } from './dynamicNamePath';
 
@@ -99,54 +100,63 @@ export class FormItemModel<T extends DefaultStructure = DefaultStructure> extend
 
   renderItem() {
     const fieldModel = this.subModels.field as FieldModel;
-    // 行索引（来自数组子表单）
     const idx = this.context.fieldIndex;
     const fieldKey = this.context.fieldKey;
     const parentFieldPathArray = this.parent?.context.fieldPathArray || [];
+    const isHiddenReservedValuePreview =
+      !!this.context.flowSettingsEnabled && !!this.props.hidden && !this.hidden && !this.forbidden;
 
-    // 嵌套场景下继续传透，为字段子模型创建 fork
     const modelForRender =
-      idx != null
+      idx != null || isHiddenReservedValuePreview
         ? (() => {
-            const fork = fieldModel.createFork({}, `${fieldKey}`);
-            fork.context.defineProperty('fieldIndex', {
-              get: () => idx,
-            });
-            fork.context.defineProperty('fieldKey', {
-              get: () => fieldKey,
-            });
-            if (this.context.currentObject) {
-              fork.context.defineProperty('currentObject', {
-                get: () => this.context.currentObject,
+            const forkKey = isHiddenReservedValuePreview ? `${this.uid}:config-visible` : `${fieldKey}`;
+            const fork = fieldModel.createFork({}, forkKey);
+            if (idx != null) {
+              fork.context.defineProperty('fieldIndex', {
+                get: () => idx,
               });
-            }
-            const itemOptions = this.context.getPropertyOptions('item');
-            if (this.context.item) {
-              const { value: _value, ...rest } = (itemOptions || {}) as any;
-              fork.context.defineProperty('item', {
-                ...rest,
-                get: () => this.context.item,
-                cache: false,
+              fork.context.defineProperty('fieldKey', {
+                get: () => fieldKey,
               });
+              if (this.context.currentObject) {
+                fork.context.defineProperty('currentObject', {
+                  get: () => this.context.currentObject,
+                });
+              }
+              const itemOptions = this.context.getPropertyOptions('item');
+              if (this.context.item) {
+                const { value: _value, ...rest } = (itemOptions || {}) as any;
+                fork.context.defineProperty('item', {
+                  ...rest,
+                  get: () => this.context.item,
+                  cache: false,
+                });
+              }
+              if (this.context.pattern) {
+                fork.context.defineProperty('pattern', {
+                  get: () => this.context.pattern,
+                });
+              }
             }
-            if (this.context.pattern) {
-              fork.context.defineProperty('pattern', {
-                get: () => this.context.pattern,
-              });
+            if (isHiddenReservedValuePreview) {
+              fork.setProps({ hidden: false });
             }
             return fork;
           })()
         : fieldModel;
     const mergedProps = this.context.pattern ? { ...this.props, pattern: this.context.pattern } : this.props;
-    const { initialValue, ...mergedPropsWithoutInitial } = mergedProps as any;
+    const { initialValue, hidden, ...mergedPropsWithoutInitial } = mergedProps as any;
+    const formItemProps = isHiddenReservedValuePreview
+      ? mergedPropsWithoutInitial
+      : { hidden, ...mergedPropsWithoutInitial };
     const fieldPath = buildDynamicNamePath(this.props.name, idx);
     this.context.defineProperty('fieldPathArray', {
       value: [...parentFieldPathArray, ..._.castArray(fieldPath)],
     });
     const record = this.context.item?.value || this.context.record;
-    return (
+    const content = (
       <FormItem
-        {...mergedPropsWithoutInitial}
+        {...formItemProps}
         name={fieldPath}
         validateFirst={true}
         disabled={
@@ -158,6 +168,16 @@ export class FormItemModel<T extends DefaultStructure = DefaultStructure> extend
         <FieldModelRenderer model={modelForRender} name={fieldPath} />
       </FormItem>
     );
+
+    if (isHiddenReservedValuePreview) {
+      return (
+        <Tooltip title={this.context.t('The field is hidden and only visible when the UI Editor is active')}>
+          <div style={{ opacity: 0.3 }}>{content}</div>
+        </Tooltip>
+      );
+    }
+
+    return content;
   }
 }
 

package/src/flow/models/blocks/shared/filterOperators.ts

@@ -0,0 +1,14 @@
+/**
+ * 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.
+ */
+
+export function isArrayLikeField(field: any) {
+  return (
+    ['multipleSelect', 'checkboxGroup'].includes(field?.interface) || ['array', 'json', 'jsonb'].includes(field?.type)
+  );
+}

package/src/flow/models/blocks/table/TableBlockModel.tsx

@@ -563,6 +563,9 @@ export class TableBlockModel extends CollectionBlockModel<TableBlockModelStructu
           columns={this.columns.value}
           pagination={this.pagination()}
           highlightedRowKey={highlightedRowKey}
+          selectedRowKeysFromResource={this.resource
+            .getSelectedRows()
+            .map((row) => getRowKey(row, this.collection.filterTargetKey))}
           defaultExpandAllRows={this.props.defaultExpandAllRows}
           expandedRowKeys={this.props.expandedRowKeys}
           heightMode={heightMode}
@@ -581,6 +584,7 @@ const TableBlockContent = (props: {
   columns: any;
   pagination: any;
   highlightedRowKey: string;
+  selectedRowKeysFromResource: string[];
   defaultExpandAllRows?: boolean;
   expandedRowKeys?: any[];
   heightMode?: string;
@@ -594,6 +598,7 @@ const TableBlockContent = (props: {
     columns,
     pagination,
     highlightedRowKey,
+    selectedRowKeysFromResource,
     defaultExpandAllRows,
     expandedRowKeys,
     heightMode,
@@ -620,6 +625,7 @@ const TableBlockContent = (props: {
           columns={columns}
           pagination={pagination}
           highlightedRowKey={highlightedRowKey}
+          selectedRowKeysFromResource={selectedRowKeysFromResource}
           defaultExpandAllRows={defaultExpandAllRows}
           expandedRowKeys={expandedRowKeys}
           tableScroll={tableScroll}
@@ -829,6 +835,7 @@ const HighPerformanceTable = React.memo(
     columns: any;
     pagination: any;
     highlightedRowKey: string;
+    selectedRowKeysFromResource: string[];
     defaultExpandAllRows?: boolean;
     expandedRowKeys?: any[];
     tableScroll;
@@ -841,6 +848,7 @@ const HighPerformanceTable = React.memo(
       columns,
       pagination: _pagination,
       highlightedRowKey,
+      selectedRowKeysFromResource,
       defaultExpandAllRows,
       expandedRowKeys,
       tableScroll,
@@ -848,9 +856,17 @@ const HighPerformanceTable = React.memo(
     const dataSourceRef = useRef(dataSource);
     dataSourceRef.current = dataSource;
 
-    const [selectedRowKeys, setSelectedRowKeys] = React.useState<string[]>(() =>
-      model.resource.getSelectedRows().map((row) => getRowKey(row, model.collection.filterTargetKey)),
-    );
+    const [selectedRowKeys, setSelectedRowKeys] = React.useState<string[]>(selectedRowKeysFromResource || []);
+
+    useEffect(() => {
+      const nextSelectedRowKeys = selectedRowKeysFromResource || [];
+      setSelectedRowKeys((prev) => {
+        if (_.isEqual(prev, nextSelectedRowKeys)) {
+          return prev;
+        }
+        return nextSelectedRowKeys;
+      });
+    }, [selectedRowKeysFromResource]);
 
     const getRowKeyFunc = useCallback(
       (record) => {

package/src/flow/models/fields/DividerItemModel.tsx

@@ -8,25 +8,40 @@
  */
 
 import { FormItem } from '@nocobase/flow-engine';
-import { Divider } from 'antd';
+import { Divider, theme } from 'antd';
 import React from 'react';
 import { CommonItemModel } from '../base/CommonItemModel';
 import { NBColorPicker } from './ColorFieldModel';
 
+const resolveThemeColor = (value: string | undefined, fallback: string) => {
+  return value ? value : fallback;
+};
+
+const DividerItem = (props: any) => {
+  const { token } = theme.useToken();
+  const { color, borderColor, label, orientation, dashed } = props;
+
+  return (
+    <Divider
+      type="horizontal"
+      style={{
+        color: resolveThemeColor(color, token.colorText),
+        borderColor: resolveThemeColor(borderColor, token.colorSplit),
+      }}
+      orientationMargin="0"
+      orientation={orientation}
+      dashed={dashed}
+    >
+      {label}
+    </Divider>
+  );
+};
+
 export class DividerItemModel extends CommonItemModel {
   render() {
-    const { color, borderColor, label, orientation, dashed } = this.props;
     return (
       <FormItem shouldUpdate showLabel={false}>
-        <Divider
-          type="horizontal"
-          style={{ color, borderColor }}
-          orientationMargin="0"
-          orientation={orientation}
-          dashed={dashed}
-        >
-          {label}
-        </Divider>
+        <DividerItem {...this.props} />
       </FormItem>
     );
   }
@@ -38,12 +53,12 @@ DividerItemModel.registerFlow({
   steps: {
     title: {
       title: '{{t("Edit divider")}}',
-      defaultParams: {
+      defaultParams: (ctx) => ({
         label: '{{t("Text")}}',
         orientation: 'left',
-        color: 'rgba(0, 0, 0, 0.88)',
-        borderColor: 'rgba(5, 5, 5, 0.06)',
-      },
+        color: ctx.themeToken?.colorText,
+        borderColor: ctx.themeToken?.colorSplit,
+      }),
       uiSchema(ctx) {
         return {
           label: {

package/src/flow-compat/data.ts

@@ -7,15 +7,37 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { DataSourceManager } from '@nocobase/flow-engine';
+import { getCollectionFieldInterface } from '@nocobase/flow-engine';
+import type { CollectionFieldInterfaceDataSourceManager } from '@nocobase/flow-engine';
 
 export interface CollectionFieldOptions {
   interface?: string;
   [key: string]: any;
 }
 
+type FieldInterfaceOptions = { titleUsable?: boolean } | null | undefined;
+
 export const DEFAULT_DATA_SOURCE_KEY = 'main';
 
-export const isTitleField = (dm: DataSourceManager, field: CollectionFieldOptions) => {
-  return dm.collectionFieldInterfaceManager?.getFieldInterface(field.interface)?.titleUsable;
+export const getFlowFieldInterfaceOptions = (
+  interfaceName: string | undefined,
+  ...dataSourceManagers: Array<CollectionFieldInterfaceDataSourceManager | null | undefined>
+) => getCollectionFieldInterface(interfaceName, ...dataSourceManagers);
+
+export const hasFlowFieldInterfaceLookup = (
+  ...dataSourceManagers: Array<CollectionFieldInterfaceDataSourceManager | null | undefined>
+) =>
+  dataSourceManagers.some(
+    (dataSourceManager) => typeof dataSourceManager?.collectionFieldInterfaceManager?.getFieldInterface === 'function',
+  );
+
+export const isTitleFieldInterface = (fieldInterfaceOptions: FieldInterfaceOptions) => {
+  return fieldInterfaceOptions?.titleUsable;
+};
+
+export const isTitleField = (
+  dataSourceManager: CollectionFieldInterfaceDataSourceManager | null | undefined,
+  field: CollectionFieldOptions | null | undefined,
+) => {
+  return isTitleFieldInterface(getFlowFieldInterfaceOptions(field?.interface, dataSourceManager));
 };

package/src/flow-compat/index.ts

@@ -11,7 +11,13 @@ export { Plugin } from '../Plugin';
 export { useApp } from '../hooks/useApp';
 export { usePlugin } from '../hooks/usePlugin';
 export { ColorPicker } from './ColorPicker';
-export { DEFAULT_DATA_SOURCE_KEY, isTitleField } from './data';
+export {
+  DEFAULT_DATA_SOURCE_KEY,
+  getFlowFieldInterfaceOptions,
+  hasFlowFieldInterfaceLookup,
+  isTitleField,
+  isTitleFieldInterface,
+} from './data';
 export { FieldValidation } from './FieldValidation';
 export { HighPerformanceSpin } from './HighPerformanceSpin';
 export { Icon, hasIcon, icons, registerIcon, registerIcons } from './Icon';

package/src/index.ts

@@ -32,5 +32,5 @@ export * from './collection-field-interface/CollectionFieldInterface';
 export * from './collection-field-interface/CollectionFieldInterfaceManager';
 export * from './collection-manager/interfaces';
 export * from './flow';
-export { DEFAULT_DATA_SOURCE_KEY, isTitleField } from './flow-compat';
+export { DEFAULT_DATA_SOURCE_KEY, isTitleField, isTitleFieldInterface } from './flow-compat';
 export { default as AntdAppProvider } from './theme/AntdAppProvider';