@nocobase/client-v2 2.1.0-beta.22 → 2.1.0-beta.23

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

@@ -0,0 +1,75 @@
+/**
+ * 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 { tExpr, observable } from '@nocobase/flow-engine';
+import { castArray } from 'lodash';
+import { BlockSceneEnum } from '../../base/BlockModel';
+import { TableBlockModel } from './TableBlockModel';
+
+export class TableSelectModel extends TableBlockModel {
+  static scene = BlockSceneEnum.select;
+  rowSelectionProps: any = observable.deep({});
+  onInit(options: any) {
+    super.onInit(options);
+    const collectionField = this.context.view.inputArgs.collectionField || {};
+    const isOToAny = ['oho', 'o2m'].includes(collectionField?.interface);
+    const sourceId = this.context.view.inputArgs.sourceId;
+    if (isOToAny) {
+      const foreignKey = collectionField.foreignKey;
+      const filterGroupKey = `${this.uid}-${collectionField.name}`;
+      if (foreignKey) {
+        if (sourceId != null) {
+          this.resource.addFilterGroup(filterGroupKey, {
+            $or: [{ [foreignKey]: { $is: null } }, { [foreignKey]: { $eq: sourceId } }],
+          });
+        } else {
+          this.resource.addFilterGroup(filterGroupKey, {
+            [foreignKey]: {
+              $is: null,
+            },
+          });
+        }
+      }
+    }
+
+    Object.assign(this.rowSelectionProps, this.context.view.inputArgs.rowSelectionProps || {});
+
+    const getSelectedRows = this.rowSelectionProps?.defaultSelectedRows;
+    const selectData = typeof getSelectedRows === 'function' ? getSelectedRows() : getSelectedRows;
+    const data = (selectData && castArray(selectData)) || [];
+    const filterKeys = data
+      .map((v) => {
+        return v[this.collection.filterTargetKey];
+      })
+      .filter(Boolean);
+    this.resource.addFilterGroup(`${this.uid}-select`, {
+      [`${this.collection.filterTargetKey}.$ne`]: filterKeys,
+    });
+  }
+}
+
+TableSelectModel.define({
+  label: tExpr('Table'),
+  children: false,
+  useModel: 'TableSelectModel',
+  createModelOptions: async (ctx) => {
+    const { dataSourceKey, collectionName } = ctx.view.inputArgs;
+    return {
+      use: 'TableSelectModel',
+      stepParams: {
+        resourceSettings: {
+          init: {
+            dataSourceKey,
+            collectionName,
+          },
+        },
+      },
+    };
+  },
+});

package/src/flow/models/blocks/table/__tests__/TableActionsColumnModel.test.tsx

@@ -0,0 +1,282 @@
+/**
+ * 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 React from 'react';
+import { render, screen, waitFor } from '@nocobase/test/client';
+import { App, ConfigProvider } from 'antd';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { FlowEngine, FlowEngineProvider } from '@nocobase/flow-engine';
+import { ActionModel } from '../../../base/ActionModel';
+import { TableActionsColumnModel } from '../TableActionsColumnModel';
+
+const capturedDroppableUids: string[] = [];
+const capturedRendererProps: any[] = [];
+let latestOnDragEnd: ((event: any) => void) | undefined;
+const capturedDndProviders: Array<{ persist: boolean }> = [];
+
+vi.mock('@nocobase/flow-engine', async () => {
+  const actual = await vi.importActual<any>('@nocobase/flow-engine');
+  return {
+    ...actual,
+    DndProvider: ({ children, onDragEnd, persist = true, ...restProps }) => {
+      const engine = actual.useFlowEngine();
+      const handleDragEnd = (event: any) => {
+        if (onDragEnd) {
+          onDragEnd(event);
+        } else if (event?.over) {
+          engine.moveModel(event.active?.id, event.over?.id, { persist });
+        }
+      };
+      latestOnDragEnd = handleDragEnd;
+      capturedDndProviders.push({ persist });
+      return (
+        <div data-test-dnd-provider {...restProps}>
+          {children}
+        </div>
+      );
+    },
+    Droppable: ({ model, children }) => {
+      capturedDroppableUids.push(model.uid);
+      return <div data-test-droppable={model.uid}>{children}</div>;
+    },
+    FlowModelRenderer: (props) => {
+      capturedRendererProps.push(props);
+      const ActualFlowModelRenderer = actual.FlowModelRenderer;
+      return <ActualFlowModelRenderer {...props} />;
+    },
+  };
+});
+
+class TestViewActionModel extends ActionModel {
+  defaultProps: any = { type: 'link', title: 'View' };
+}
+
+class TestAlwaysActionModel extends ActionModel {
+  defaultProps: any = { type: 'link', title: 'Always' };
+}
+
+// 在 beforeRender 中，根据 inputArgs（即当前行 record）决定是否隐藏按钮
+TestViewActionModel.registerFlow({
+  key: 'autoHideByPhone',
+  steps: {
+    apply: {
+      handler(ctx) {
+        const rec: any = ctx.inputArgs;
+        // 电话为 123456 时隐藏
+        ctx.model.setHidden(rec?.phone === '123456');
+      },
+    },
+  },
+});
+
+describe('TableActionsColumnModel: pass record via inputArgs to FlowModelRenderer', () => {
+  it('cell render: action button hides when record.phone updates to 123456', async () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ TableActionsColumnModel, TestViewActionModel });
+
+    // 创建仅包含行内 actions 的列模型
+    const actionsCol = engine.createModel<TableActionsColumnModel>({
+      use: 'TableActionsColumnModel',
+      props: { width: 200, title: 'Actions' },
+      subModels: { actions: [{ use: 'TestViewActionModel' }] },
+    });
+
+    // 获取列渲染器（TableActionsColumnModel 内部会在单元格内通过 FlowModelRenderer 传递 inputArgs=record）
+    const colProps = actionsCol.getColumnProps();
+
+    const record1 = { id: 1, phone: '666666' };
+    const record2 = { id: 1, phone: '123456' };
+
+    const { rerender } = render(
+      <FlowEngineProvider engine={engine}>
+        <ConfigProvider>
+          <App>{colProps.render?.(undefined, record1, 0) as any}</App>
+        </ConfigProvider>
+      </FlowEngineProvider>,
+    );
+
+    await waitFor(
+      () => {
+        expect(screen.getByText('View')).toBeInTheDocument();
+      },
+      { timeout: 5000 },
+    );
+
+    // 以相同行索引（0）重渲染，内部 fork 复用了同一个 key，并会在 beforeRender 前失效缓存
+    rerender(
+      <FlowEngineProvider engine={engine}>
+        <ConfigProvider>
+          <App>{colProps.render?.(undefined, record2, 0) as any}</App>
+        </ConfigProvider>
+      </FlowEngineProvider>,
+    );
+
+    await waitFor(
+      () => {
+        expect(screen.queryByText('View')).toBeNull();
+      },
+      { timeout: 5000 },
+    );
+  });
+});
+
+describe('TableActionsColumnModel: hidden action layout', () => {
+  it('does not leave empty slot when first action is hidden by linkage', async () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ TableActionsColumnModel, TestViewActionModel, TestAlwaysActionModel });
+
+    const actionsCol = engine.createModel<TableActionsColumnModel>({
+      use: 'TableActionsColumnModel',
+      props: { width: 200, title: 'Actions' },
+      subModels: { actions: [{ use: 'TestViewActionModel' }, { use: 'TestAlwaysActionModel' }] },
+    });
+
+    const colProps = actionsCol.getColumnProps();
+    const record = { id: 1, phone: '123456' } as any;
+
+    const { container } = render(
+      <FlowEngineProvider engine={engine}>
+        <ConfigProvider>
+          <App>{colProps.render?.(undefined, record, 0) as any}</App>
+        </ConfigProvider>
+      </FlowEngineProvider>,
+    );
+
+    await waitFor(() => {
+      expect(screen.queryByText('View')).toBeNull();
+      expect(screen.getByText('Always')).toBeInTheDocument();
+    });
+
+    const [, secondUid] = actionsCol.mapSubModels('actions', (action) => action.uid);
+    const wrappers = container.querySelectorAll('[data-test-droppable]');
+    expect(wrappers).toHaveLength(0);
+    expect(secondUid).toBeTruthy();
+  });
+});
+
+describe('TableActionsColumnModel: drag integration', () => {
+  beforeEach(() => {
+    capturedDroppableUids.length = 0;
+    capturedRendererProps.length = 0;
+    capturedDndProviders.length = 0;
+    latestOnDragEnd = undefined;
+  });
+
+  it('wraps header and each action with Droppable inside DndProvider', async () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ TableActionsColumnModel, TestViewActionModel });
+
+    const actionsCol = engine.createModel<TableActionsColumnModel>({
+      use: 'TableActionsColumnModel',
+      props: { width: 200, title: 'Actions' },
+      subModels: { actions: [{ use: 'TestViewActionModel' }, { use: 'TestViewActionModel' }] },
+    });
+
+    const colProps = actionsCol.getColumnProps();
+    const record = { id: 1, phone: '000000' } as any;
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <ConfigProvider>
+          <App>
+            <>
+              {colProps.title as React.ReactNode}
+              {colProps.render?.(undefined, record, 0) as any}
+            </>
+          </App>
+        </ConfigProvider>
+      </FlowEngineProvider>,
+    );
+
+    await waitFor(() => {
+      expect(screen.getAllByText('View').length).toBe(2);
+    });
+
+    expect(capturedDroppableUids).toEqual([actionsCol.uid]);
+    expect(capturedDndProviders.length).toBe(1);
+    expect(capturedDndProviders[0].persist).toBe(true);
+  });
+
+  it('injects drag toolbar item and binds record context on action forks', async () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ TableActionsColumnModel, TestViewActionModel });
+
+    const actionsCol = engine.createModel<TableActionsColumnModel>({
+      use: 'TableActionsColumnModel',
+      props: { width: 200, title: 'Actions' },
+      subModels: { actions: [{ use: 'TestViewActionModel' }] },
+    });
+
+    const colProps = actionsCol.getColumnProps();
+    const record = { id: 1, phone: '000000', name: 'John' } as any;
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <ConfigProvider>
+          <App>{colProps.render?.(undefined, record, 0) as any}</App>
+        </ConfigProvider>
+      </FlowEngineProvider>,
+    );
+
+    await waitFor(() => {
+      expect(screen.getByText('View')).toBeInTheDocument();
+    });
+
+    const rendererProps = capturedRendererProps.at(-1);
+    expect(rendererProps).toBeDefined();
+    if (!rendererProps) {
+      throw new Error('FlowModelRenderer props missing for drag integration test');
+    }
+    expect(rendererProps.extraToolbarItems).toEqual(
+      expect.arrayContaining([expect.objectContaining({ key: 'drag-handler', sort: 1 })]),
+    );
+
+    const forkModel = rendererProps.model as ActionModel;
+    expect((forkModel.context as any).record).toBe(record);
+    expect((forkModel.context as any).recordIndex).toBe(0);
+  });
+
+  it('uses default moveModel behaviour when drag ends and no custom handler supplied', async () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ TableActionsColumnModel, TestViewActionModel });
+
+    const actionsCol = engine.createModel<TableActionsColumnModel>({
+      use: 'TableActionsColumnModel',
+      props: { width: 200, title: 'Actions' },
+      subModels: { actions: [{ use: 'TestViewActionModel' }, { use: 'TestViewActionModel' }] },
+    });
+
+    const colProps = actionsCol.getColumnProps();
+    const record = { id: 1, phone: '000000' } as any;
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <ConfigProvider>
+          <App>{colProps.render?.(undefined, record, 0) as any}</App>
+        </ConfigProvider>
+      </FlowEngineProvider>,
+    );
+
+    await waitFor(() => {
+      expect(screen.getAllByText('View').length).toBeGreaterThan(0);
+    });
+
+    const moveModelSpy = vi.spyOn(engine, 'moveModel');
+    const [firstUid, secondUid] = actionsCol.mapSubModels('actions', (action) => action.uid);
+
+    expect(latestOnDragEnd).toBeTypeOf('function');
+    if (!latestOnDragEnd) {
+      throw new Error('DndProvider did not expose onDragEnd handler');
+    }
+
+    latestOnDragEnd({ active: { id: firstUid }, over: { id: secondUid } });
+
+    expect(moveModelSpy).toHaveBeenCalledWith(firstUid, secondUid, { persist: true });
+  });
+});

package/src/flow/models/blocks/table/__tests__/TableBlockModel.blockHeight.test.tsx

@@ -0,0 +1,120 @@
+/**
+ * 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 React, { useRef } from 'react';
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { render, screen, waitFor } from '@testing-library/react';
+import { useBlockHeight } from '../utils';
+
+const createRect = (height: number) => ({
+  x: 0,
+  y: 0,
+  width: 100,
+  height,
+  top: 0,
+  left: 0,
+  right: 100,
+  bottom: height,
+  toJSON: () => {},
+});
+
+const setRect = (node: HTMLElement | null, height: number) => {
+  if (!node) return;
+  node.getBoundingClientRect = () => createRect(height);
+};
+
+const HeightProbe = ({
+  heightMode,
+  areaHeight,
+  headerHeight,
+  paginationHeight,
+  depsKey,
+}: {
+  heightMode?: string;
+  areaHeight: number;
+  headerHeight: number;
+  paginationHeight: number;
+  depsKey: number;
+}) => {
+  const tableAreaRef = useRef<HTMLDivElement>(null);
+  const scrollY = useBlockHeight({
+    heightMode,
+    tableAreaRef,
+    deps: [depsKey],
+  });
+
+  return (
+    <div>
+      <div
+        ref={(node) => {
+          tableAreaRef.current = node;
+          setRect(node, areaHeight);
+        }}
+      >
+        <div
+          className="ant-table-header"
+          ref={(node) => {
+            setRect(node, headerHeight);
+          }}
+        />
+        <div
+          className="ant-table-pagination"
+          ref={(node) => {
+            setRect(node, paginationHeight);
+          }}
+        />
+      </div>
+      <span data-testid="scroll">{scrollY === undefined ? 'undefined' : String(scrollY)}</span>
+    </div>
+  );
+};
+
+describe('TableBlockModel block height', () => {
+  const originalResizeObserver = globalThis.ResizeObserver;
+
+  beforeAll(() => {
+    if (typeof globalThis.ResizeObserver === 'undefined') {
+      globalThis.ResizeObserver = class {
+        observe() {}
+        unobserve() {}
+        disconnect() {}
+      } as any;
+    }
+  });
+
+  afterAll(() => {
+    globalThis.ResizeObserver = originalResizeObserver;
+  });
+
+  it('calculates scrollY when heightMode is fixed', async () => {
+    render(
+      <HeightProbe heightMode="specifyValue" areaHeight={300} headerHeight={40} paginationHeight={30} depsKey={1} />,
+    );
+
+    await waitFor(() => {
+      expect(screen.getByTestId('scroll').textContent).toBe('230');
+    });
+  });
+
+  it('clears scrollY when heightMode is not fixed', async () => {
+    const { rerender } = render(
+      <HeightProbe heightMode="specifyValue" areaHeight={300} headerHeight={40} paginationHeight={30} depsKey={1} />,
+    );
+
+    await waitFor(() => {
+      expect(screen.getByTestId('scroll').textContent).toBe('230');
+    });
+
+    rerender(<HeightProbe heightMode="default" areaHeight={300} headerHeight={40} paginationHeight={30} depsKey={2} />);
+
+    await waitFor(() => {
+      expect(screen.getByTestId('scroll').textContent).toBe('undefined');
+    });
+  });
+});

package/src/flow/models/blocks/table/__tests__/TableBlockModel.popupSourceId.test.ts

@@ -0,0 +1,87 @@
+/**
+ * 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, it, expect, vi } from 'vitest';
+import '../../../../index';
+import { FlowEngine } from '@nocobase/flow-engine';
+import { TableBlockModel } from '../TableBlockModel';
+
+describe('TableBlockModel popup sourceId load', () => {
+  it('Non-id association field should use ctx.popup.record.sourceKey', async () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ TableBlockModel });
+
+    // 1) 准备数据源：users.hasMany(orders)，且关联使用 sourceKey=code（非 id 字段）
+    const ds = engine.dataSourceManager.getDataSource('main');
+    ds.addCollection({
+      name: 'orders',
+      filterTargetKey: 'id',
+      fields: [
+        { name: 'id', type: 'integer', interface: 'number' },
+        { name: 'user_code', type: 'string', interface: 'text' },
+      ],
+    });
+    ds.addCollection({
+      name: 'users',
+      filterTargetKey: 'id',
+      fields: [
+        { name: 'id', type: 'integer', interface: 'number' },
+        { name: 'code', type: 'string', interface: 'text' },
+        {
+          name: 'orders',
+          title: 'Orders',
+          type: 'hasMany',
+          target: 'orders',
+          interface: 'o2m',
+          sourceKey: 'code',
+          foreignKey: 'user_code',
+        },
+      ],
+    });
+
+    // 2) 注入 API mock，断言请求路径带入了 popup.record.code
+    const api = {
+      request: vi.fn(async (config: any) => {
+        expect(config.url).toBe('users/USER-001/orders:list');
+        return { data: { data: [], meta: {} } } as any;
+      }),
+    } as any;
+    engine.context.defineProperty('api', { value: api });
+
+    // 3) 通过 defineChildren 获取关联区块的初始化参数，确保 sourceId 模板正确
+    const designerCtx = {
+      dataSourceManager: engine.dataSourceManager,
+      view: { inputArgs: { dataSourceKey: 'main', collectionName: 'users' } },
+    } as any;
+    const children = (await TableBlockModel.defineChildren(designerCtx)) as any[];
+    const associated = children.find((item) => String(item.key).includes('associated'));
+    const assocBlocks = associated.children(designerCtx) as any[];
+    const ordersBlock = assocBlocks.find((item) => String(item.key).includes('orders'));
+    const initOptions = ordersBlock.createModelOptions?.stepParams?.resourceSettings?.init;
+    expect(initOptions?.sourceId).toBe('{{ctx.popup.record.code}}');
+
+    // 4) 创建关联表格区块模型，提供 popup.record（code 与 filterByTk 不同）
+    const modelOptions = {
+      ...ordersBlock.createModelOptions,
+      uid: 'orders-table',
+    };
+    const tableModel = engine.createModel<TableBlockModel>(modelOptions as any);
+    tableModel.context.defineProperty('view', { value: { inputArgs: { filterByTk: 99 } } });
+    tableModel.context.defineProperty('popup', { value: { record: { code: 'USER-001', id: 1 } } });
+
+    // 5) 运行资源初始化与刷新，确认 sourceId 取自 popup.record.code
+    await tableModel.applyFlow('resourceSettings');
+    expect(tableModel.resource.getSourceId()).toBe('USER-001');
+
+    await tableModel.resource.refresh();
+    expect(api.request).toHaveBeenCalledTimes(1);
+    const [reqConfig] = api.request.mock.calls[0] as any[];
+    expect(reqConfig.url).toBe('users/USER-001/orders:list');
+  });
+});

package/src/flow/models/blocks/table/__tests__/TableColumnModel.test.tsx

@@ -0,0 +1,72 @@
+/**
+ * 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 } from '@nocobase/flow-engine';
+import { describe, expect, it } from 'vitest';
+import { TableColumnModel } from '../TableColumnModel';
+
+describe('TableColumnModel sorter settings', () => {
+  it('hides sortable setting for association fields', async () => {
+    const engine = new FlowEngine();
+    const model = new TableColumnModel({ uid: 'table-column-association-sorter', flowEngine: engine } as any);
+    const sorterStep = model.getFlow('tableColumnSettings')?.steps?.sorter as any;
+
+    const hidden = await sorterStep.hideInSettings({
+      model: {
+        collectionField: {
+          getInterfaceOptions: () => ({ sortable: true }),
+        },
+      },
+      collectionField: {
+        isAssociationField: () => true,
+      },
+    });
+
+    expect(hidden).toBe(true);
+  });
+
+  it('keeps sortable setting visible for sortable non-association fields', async () => {
+    const engine = new FlowEngine();
+    const model = new TableColumnModel({ uid: 'table-column-basic-sorter', flowEngine: engine } as any);
+    const sorterStep = model.getFlow('tableColumnSettings')?.steps?.sorter as any;
+
+    const hidden = await sorterStep.hideInSettings({
+      model: {
+        collectionField: {
+          getInterfaceOptions: () => ({ sortable: true }),
+        },
+      },
+      collectionField: {
+        isAssociationField: () => false,
+      },
+    });
+
+    expect(hidden).toBeFalsy();
+  });
+
+  it('hides sortable setting for relation path columns added from association groups', async () => {
+    const engine = new FlowEngine();
+    const model = new TableColumnModel({ uid: 'table-column-relation-path-sorter', flowEngine: engine } as any);
+    const sorterStep = model.getFlow('tableColumnSettings')?.steps?.sorter as any;
+
+    const hidden = await sorterStep.hideInSettings({
+      model: {
+        associationPathName: 'department',
+        collectionField: {
+          getInterfaceOptions: () => ({ sortable: true }),
+        },
+      },
+      collectionField: {
+        isAssociationField: () => false,
+      },
+    });
+
+    expect(hidden).toBe(true);
+  });
+});

package/src/flow/models/blocks/table/__tests__/sortUtils.test.ts

@@ -0,0 +1,58 @@
+/**
+ * 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 } from 'vitest';
+
+import { getTableColumnSortField, resolveTableSorterField } from '../sortUtils';
+
+describe('table sort utils', () => {
+  it('builds a relation sort path from the selected association title field', () => {
+    const sortField = getTableColumnSortField({
+      fieldPath: 'org_oho',
+      props: {
+        dataIndex: 'orgname',
+        titleField: 'orgname',
+      },
+      collectionField: {
+        name: 'org_oho',
+        targetCollectionTitleFieldName: 'nickname',
+        isAssociationField: () => true,
+      },
+      getStepParams: () => ({ label: 'orgname' }),
+    });
+
+    expect(sortField).toBe('org_oho.orgname');
+  });
+
+  it('falls back to the column field path for non-association fields', () => {
+    const sortField = getTableColumnSortField({
+      fieldPath: 'title',
+      props: {
+        dataIndex: 'title',
+      },
+      collectionField: {
+        name: 'title',
+        isAssociationField: () => false,
+      },
+    });
+
+    expect(sortField).toBe('title');
+  });
+
+  it('prefers the explicit column sort field over antd sorter field', () => {
+    expect(
+      resolveTableSorterField({
+        field: 'orgname',
+        column: {
+          sortField: 'org_oho.orgname',
+        },
+      }),
+    ).toBe('org_oho.orgname');
+  });
+});