@nocobase/client-v2 2.3.0-beta.2 → 2.3.0-beta.21

package/src/flow/models/fields/AssociationFieldModel/__tests__/RecordSelectFieldModel.quickCreatePopup.test.tsx

@@ -0,0 +1,183 @@
+/**
+ * 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,
+  FlowEngine,
+  FlowEngineProvider,
+  FlowViewContextProvider,
+  type FlowModel,
+} from '@nocobase/flow-engine';
+import { cleanup, render, screen, waitFor } from '@testing-library/react';
+import React from 'react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import '../../../index';
+import { BlockGridModel } from '../../../base/BlockGridModel';
+import { RecordSelectFieldModel } from '../RecordSelectFieldModel';
+
+type OpenViewHandler = (ctx: unknown, params: Record<string, unknown>) => void;
+
+function getOpenViewHandler(): OpenViewHandler {
+  const flow = RecordSelectFieldModel.globalFlowRegistry.getFlow('popupSettings');
+  const handler = flow?.getStep('openView')?.serialize().handler;
+
+  if (!handler) {
+    throw new Error('popupSettings.openView handler is not registered');
+  }
+
+  return handler as OpenViewHandler;
+}
+
+function createContext(record: Record<string, unknown>) {
+  const open = vi.fn();
+  const sourceCollection = {
+    getFilterByTK: vi.fn((sourceRecord: Record<string, unknown>) => sourceRecord.id),
+  };
+  const model = {
+    uid: 'record-select-uid',
+    props: {
+      quickCreate: 'modalAdd',
+      allowMultiple: true,
+    },
+    context: {
+      inputArgs: {},
+      flowSettingsEnabled: false,
+    },
+    flowEngine: {
+      context: {
+        themeToken: {
+          colorBgLayout: '#fff',
+        },
+      },
+    },
+  };
+
+  return {
+    open,
+    context: {
+      inputArgs: { onChange: vi.fn() },
+      view: {
+        inputArgs: {
+          viewUid: 'approval-popup-uid',
+        },
+      },
+      viewer: { open },
+      layoutContentElement: {},
+      model,
+      collection: {
+        dataSourceKey: 'main',
+        filterTargetKey: 'id',
+      },
+      collectionField: {
+        type: 'hasMany',
+        target: 'orgs',
+        resourceName: 'users.orgs',
+        collection: sourceCollection,
+      },
+      record,
+    },
+  };
+}
+
+describe('RecordSelectFieldModel quick create popup', () => {
+  afterEach(() => {
+    cleanup();
+    vi.restoreAllMocks();
+  });
+
+  describe.each(['drawer', 'dialog'])('%s configuration mode', (mode) => {
+    it.each([
+      { scenario: 'configuration', modelEnabled: true, globalEnabled: false },
+      { scenario: 'global configuration', modelEnabled: true, globalEnabled: true },
+      { scenario: 'runtime', modelEnabled: false, globalEnabled: false },
+      { scenario: 'read-only configuration', modelEnabled: false, globalEnabled: true },
+    ])('uses the field configuration state in $scenario', async ({ modelEnabled, globalEnabled }) => {
+      const engine = new FlowEngine();
+      engine.registerModels({ BlockGridModel });
+      engine.flowSettings.enabled = globalEnabled;
+      engine.context.defineProperty('themeToken', {
+        value: { marginBlock: 16, marginSM: 8, paddingLG: 24 },
+      });
+      engine.context.defineProperty('t', { value: (key: string) => key });
+      const save = vi.fn(async (model: FlowModel) => model.serialize());
+      engine.setModelRepository({
+        findOne: vi.fn(async () => null),
+        save,
+        destroy: vi.fn(async () => true),
+        move: vi.fn(async () => undefined),
+        duplicate: vi.fn(async () => null),
+      });
+      const load = vi.spyOn(engine, 'loadOrCreateModel');
+      const { context, open } = createContext({});
+      context.model.context.flowSettingsEnabled = modelEnabled;
+      getOpenViewHandler()(context, { mode, size: 'medium' });
+      const config = open.mock.calls[0][0];
+      expect(config.inheritContext).toBe(false);
+
+      // Detached popups inherit the engine context, not the approval form's model context.
+      const popupContext = new FlowContext();
+      popupContext.addDelegate(engine.context);
+      popupContext.defineProperty('engine', { value: engine });
+      popupContext.defineProperty('view', {
+        value: { type: mode, inputArgs: config.inputArgs, Header: () => null, close: vi.fn() },
+      });
+      const { container } = render(
+        <FlowEngineProvider engine={engine}>
+          <FlowViewContextProvider context={popupContext}>{config.content()}</FlowViewContextProvider>
+        </FlowEngineProvider>,
+      );
+
+      await waitFor(() => expect(container.querySelector('.nb-block-grid')).toBeInTheDocument());
+      if (modelEnabled) {
+        expect(screen.getByRole('button', { name: /Add block/ })).toBeInTheDocument();
+        expect(save).toHaveBeenCalledOnce();
+      } else {
+        expect(screen.queryByRole('button', { name: /Add block/ })).not.toBeInTheDocument();
+        expect(save).not.toHaveBeenCalled();
+      }
+      expect(load).toHaveBeenCalledWith(
+        expect.objectContaining({ use: 'BlockGridModel', parentId: context.model.uid }),
+        { delegateToParent: false, delegate: popupContext, skipSave: !modelEnabled },
+      );
+      expect(engine.context.flowSettingsEnabled).toBe(globalEnabled);
+    });
+  });
+
+  it('passes the parent record reference when the parent record has a primary key', () => {
+    const { context, open } = createContext({ id: 1, nickname: 'Saved user' });
+
+    getOpenViewHandler()(context, { mode: 'drawer', size: 'medium' });
+
+    expect(open).toHaveBeenCalledOnce();
+    const { inputArgs } = open.mock.calls[0][0];
+    expect(inputArgs).toMatchObject({
+      scene: 'create',
+      collectionName: 'orgs',
+      associationName: 'users.orgs',
+      sourceId: 1,
+    });
+    expect(inputArgs).not.toHaveProperty('sourceAssociationName');
+  });
+
+  it('only passes sourceAssociationName when the parent record has no primary key yet', () => {
+    const { context, open } = createContext({});
+
+    getOpenViewHandler()(context, { mode: 'drawer', size: 'medium' });
+
+    expect(open).toHaveBeenCalledOnce();
+    const { inputArgs } = open.mock.calls[0][0];
+    expect(inputArgs).toMatchObject({
+      scene: 'create',
+      collectionName: 'orgs',
+      sourceAssociationName: 'users.orgs',
+    });
+    expect(inputArgs).not.toHaveProperty('associationName');
+    expect(inputArgs).not.toHaveProperty('sourceId');
+  });
+});

package/src/flow/models/fields/AssociationFieldModel/__tests__/associationSelect.search.test.ts

@@ -0,0 +1,113 @@
+/**
+ * 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 { CollectionField } from '@nocobase/flow-engine';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import '../../../index';
+import { createTypedFilterable } from '../../../../../collection-manager/filter-operators';
+import { CascadeSelectInnerFieldModel } from '../CascadeSelectFieldModel';
+import { RecordSelectFieldModel } from '../RecordSelectFieldModel';
+
+function createContext(fieldOptions: Record<string, unknown>, searchText = ' 3 ') {
+  const field = new CollectionField({ name: 'display_name', ...fieldOptions });
+  const filterable = createTypedFilterable<{ dataType?: string }>(
+    [
+      { types: ['boolean'], operators: 'boolean' },
+      { types: ['string'], operators: 'string' },
+      { types: ['integer'], operators: 'number' },
+    ],
+    (meta) => meta.dataType || 'string',
+  );
+  vi.spyOn(field, 'getInterfaceOptions').mockReturnValue({ filterable });
+  const records = [{ id: 3, display_name: '3 Jackson Hughes' }];
+  const resource = {
+    setPage: vi.fn(),
+    addFilterGroup: vi.fn(),
+    removeFilterGroup: vi.fn(),
+    refresh: vi.fn().mockResolvedValue(undefined),
+    getData: vi.fn(() => records),
+  };
+  return {
+    field,
+    inputArgs: { searchText },
+    model: {
+      collectionField: { targetCollection: { getField: vi.fn(() => field) } },
+      props: { fieldNames: { label: 'display_name', value: 'id' } },
+      resource,
+      setDataSource: vi.fn(),
+      setProps: vi.fn(),
+    },
+  };
+}
+
+describe.each([
+  { name: 'RecordSelect', model: RecordSelectFieldModel, searchGroup: '__search__display_name' },
+  { name: 'CascadeSelect', model: CascadeSelectInnerFieldModel, searchGroup: 'display_name' },
+])('$name search', ({ model, searchGroup }) => {
+  beforeEach(() => vi.useFakeTimers());
+  afterEach(() => {
+    vi.clearAllTimers();
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+  });
+
+  async function search(ctx: ReturnType<typeof createContext>) {
+    const handler = model.globalFlowRegistry.getFlow('searchSettings').getStep('step1').serialize().handler as (
+      ctx: ReturnType<typeof createContext>,
+      params: Record<string, unknown>,
+    ) => unknown;
+    handler(ctx, {});
+    await vi.advanceTimersByTimeAsync(500);
+  }
+
+  it.each([{ type: 'formula', dataType: 'string' }, { type: 'string' }])(
+    'uses partial text matching for $type labels',
+    async (options) => {
+      const ctx = createContext(options);
+
+      await search(ctx);
+
+      expect(ctx.model.resource.addFilterGroup).toHaveBeenCalledWith(searchGroup, { 'display_name.$includes': '3' });
+      expect(ctx.model.resource.setPage).toHaveBeenCalledWith(1);
+      expect(ctx.model.resource.refresh).toHaveBeenCalledOnce();
+      expect(ctx.model.setDataSource).toHaveBeenCalledWith([
+        expect.objectContaining({ display_name: '3 Jackson Hughes' }),
+      ]);
+      expect(ctx.model.setProps).toHaveBeenCalledWith({ searchText: '3' });
+    },
+  );
+
+  it('preserves the interface operator for non-string labels', async () => {
+    const ctx = createContext({ type: 'integer' });
+    vi.spyOn(ctx.field, 'getInterfaceOptions').mockReturnValue({ filterable: { operators: [{ value: '$eq' }] } });
+
+    await search(ctx);
+
+    expect(ctx.model.resource.addFilterGroup).toHaveBeenCalledWith(searchGroup, { 'display_name.$eq': '3' });
+  });
+
+  it('falls back to partial text matching without an interface', async () => {
+    const ctx = createContext({ type: 'string' });
+    vi.spyOn(ctx.field, 'getInterfaceOptions').mockReturnValue(undefined);
+
+    await search(ctx);
+
+    expect(ctx.model.resource.addFilterGroup).toHaveBeenCalledWith(searchGroup, { 'display_name.$includes': '3' });
+  });
+
+  it('removes the search filter when the search is cleared', async () => {
+    const ctx = createContext({ type: 'formula', dataType: 'string' }, '   ');
+
+    await search(ctx);
+
+    expect(ctx.model.resource.removeFilterGroup).toHaveBeenCalledWith(searchGroup);
+    expect(ctx.model.resource.addFilterGroup).not.toHaveBeenCalled();
+    expect(ctx.model.resource.refresh).toHaveBeenCalledOnce();
+  });
+});

package/src/flow/models/fields/DisplayAssociationField/DisplaySubTableFieldModel.tsx

@@ -17,14 +17,16 @@ import {
   observer,
 } from '@nocobase/flow-engine';
 import { Table } from 'antd';
+import type { TableProps } from 'antd';
 import classNames from 'classnames';
 import { DragEndEvent } from '@dnd-kit/core';
 import { css } from '@emotion/css';
-import { isEmpty } from 'lodash';
+import { get, isEmpty, orderBy } from 'lodash';
 import React, { useEffect, useMemo, useState, useCallback } from 'react';
 import { useTranslation } from 'react-i18next';
 import { FieldModel } from '../../base';
 import { DetailsItemModel } from '../../blocks/details/DetailsItemModel';
+import { FormAssociationItemModel } from '../../blocks/form/FormAssociationItemModel';
 import { adjustColumnOrder } from '../../blocks/table/utils';
 
 const HeaderWrapperComponent = React.memo((props) => {
@@ -65,11 +67,31 @@ const AddFieldColumn = ({ model }) => {
 };
 
 const DisplayTable = (props) => {
-  const { pageSize, value, size, collection, baseColumns, enableIndexColumn = true, model } = props;
+  const { pageSize, value: rawValue, size, collection, baseColumns, enableIndexColumn = true, model } = props;
+  const isFormAssociation = model.parent instanceof FormAssociationItemModel;
   const [currentPage, setCurrentPage] = useState(1);
   const [currentPageSize, setCurrentPageSize] = useState(pageSize);
+  const [localSort, setLocalSort] = useState<{ field: string; order: 'asc' | 'desc' }>();
   const { t } = useTranslation();
 
+  const value = useMemo(() => {
+    if (!isFormAssociation || Array.isArray(rawValue)) return rawValue;
+    if (rawValue && Array.isArray(rawValue.rows)) return rawValue.rows;
+    return rawValue && typeof rawValue === 'object' ? [rawValue] : [];
+  }, [isFormAssociation, rawValue]);
+
+  const sortedValue = useMemo(
+    () =>
+      isFormAssociation && localSort
+        ? orderBy(value, [(record) => get(record, localSort.field)], [localSort.order])
+        : value,
+    [isFormAssociation, localSort, value],
+  );
+
+  useEffect(() => {
+    if (isFormAssociation) setCurrentPage(1);
+  }, [isFormAssociation, rawValue]);
+
   useEffect(() => {
     setCurrentPageSize(pageSize);
   }, [pageSize]);
@@ -89,7 +111,7 @@ const DisplayTable = (props) => {
         return t('Total {{count}} items', { count: total });
       },
     } as any;
-  }, [currentPage, currentPageSize, value]);
+  }, [currentPage, currentPageSize, value, t]);
 
   const getColumns = () => {
     const cols = adjustColumnOrder(
@@ -119,8 +141,20 @@ const DisplayTable = (props) => {
     }
     return cols;
   };
-  const handleChange = useCallback(
-    async (pagination, filters, sorter) => {
+  const handleChange = useCallback<NonNullable<TableProps<Record<string, unknown>>['onChange']>>(
+    async (pagination, filters, sorters, extra) => {
+      const sorter = Array.isArray(sorters) ? sorters[0] : sorters;
+      if (isFormAssociation) {
+        if (extra.action !== 'sort') return;
+        const column = sorter?.column as { sortField?: string } | undefined;
+        const sortField = column?.sortField || sorter?.field;
+        const fullPath = Array.isArray(sortField) ? sortField.join('.') : String(sortField ?? '');
+        const prefix = `${model.context.fieldPath}.`;
+        const field = fullPath.startsWith(prefix) ? fullPath.slice(prefix.length) : fullPath;
+        setLocalSort(sorter?.order && field ? { field, order: sorter.order === 'ascend' ? 'asc' : 'desc' } : undefined);
+        setCurrentPage(1);
+        return;
+      }
       //支持列点击排序
       if (!isEmpty(sorter)) {
         const resource = model.context.blockModel.resource;
@@ -138,7 +172,7 @@ const DisplayTable = (props) => {
         await resource.refresh();
       }
     },
-    [model],
+    [isFormAssociation, model],
   );
 
   return (
@@ -147,7 +181,7 @@ const DisplayTable = (props) => {
       size={size}
       rowKey={collection.filterTargetKey}
       scroll={{ x: 'max-content' }}
-      dataSource={value}
+      dataSource={sortedValue}
       columns={getColumns()}
       pagination={pagination}
       onChange={handleChange}
@@ -269,3 +303,4 @@ DisplaySubTableFieldModel.define({
 });
 
 DetailsItemModel.bindModelToInterface('DisplaySubTableFieldModel', ['m2m', 'o2m', 'mbm']);
+FormAssociationItemModel.bindModelToInterface('DisplaySubTableFieldModel', ['m2m', 'o2m', 'mbm']);