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

package/src/flow/models/blocks/assign-form/__tests__/assignFieldValuesFlow.multipleSelect.test.tsx

@@ -0,0 +1,216 @@
+/**
+ * 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 { App, ConfigProvider } from 'antd';
+import { describe, expect, it } from 'vitest';
+import { render, waitFor } from '@nocobase/test/client';
+import {
+  FlowEngine,
+  FlowEngineProvider,
+  FlowRuntimeContext,
+  FlowSettingsContextProvider,
+  type FlowModel,
+  type IFlowModelRepository,
+} from '@nocobase/flow-engine';
+import { AssignFormGridModel } from '../AssignFormGridModel';
+import { AssignFormItemModel } from '../AssignFormItemModel';
+import { AssignFormModel } from '../AssignFormModel';
+import { createAssignFieldValuesStep } from '../assignFieldValuesFlow';
+import { InputFieldModel } from '../../../fields/InputFieldModel';
+import { SelectFieldModel } from '../../../fields/SelectFieldModel';
+import { VariableFieldFormModel } from '../../../fields/VariableFieldFormModel';
+
+class MockFlowModelRepository implements IFlowModelRepository {
+  async findOne(): Promise<Record<string, any> | null> {
+    return null;
+  }
+
+  async save(model: FlowModel): Promise<Record<string, any>> {
+    return { uid: model.uid };
+  }
+
+  async destroy(): Promise<boolean> {
+    return true;
+  }
+
+  async move(): Promise<void> {}
+
+  async duplicate(): Promise<Record<string, any> | null> {
+    return null;
+  }
+}
+
+function createEngine() {
+  const engine = new FlowEngine();
+  engine.setModelRepository(new MockFlowModelRepository());
+  engine.registerModels({
+    AssignFormModel,
+    AssignFormGridModel,
+    AssignFormItemModel,
+    InputFieldModel,
+    SelectFieldModel,
+    VariableFieldFormModel,
+  });
+  engine.context.defineProperty('location', { value: { search: '' } });
+  engine.context.defineProperty('themeToken', { value: { marginLG: 24 } });
+  return engine;
+}
+
+function addMultipleSelectCollection(engine: FlowEngine) {
+  const dsm = engine.context.dataSourceManager;
+  const main = dsm.getDataSource('main');
+  main.addCollection({
+    name: 'assign_multiple_select',
+    fields: [
+      {
+        name: 'tags',
+        type: 'array',
+        interface: 'multipleSelect',
+        uiSchema: {
+          type: 'array',
+          'x-component': 'Select',
+          'x-component-props': { mode: 'multiple' },
+          enum: [
+            { value: 'a', label: 'A' },
+            { value: 'b', label: 'B' },
+          ],
+        },
+      },
+      {
+        // Fields created before the interface default was persisted may miss `mode`.
+        name: 'legacyTags',
+        type: 'array',
+        interface: 'multipleSelect',
+        uiSchema: {
+          type: 'array',
+          'x-component': 'Select',
+          enum: [{ value: 'c', label: 'C' }],
+        },
+      },
+      {
+        name: 'tagMode',
+        type: 'array',
+        interface: 'multipleSelect',
+        uiSchema: {
+          type: 'array',
+          'x-component': 'Select',
+          'x-component-props': { mode: 'tags' },
+          enum: [{ value: 't', label: 'T' }],
+        },
+      },
+      {
+        name: 'single',
+        type: 'string',
+        interface: 'select',
+        uiSchema: {
+          type: 'string',
+          'x-component': 'Select',
+          enum: [{ value: 'x', label: 'X' }],
+        },
+      },
+      { name: 'nickname', type: 'string', interface: 'input' },
+    ],
+  });
+  return dsm.getCollection('main', 'assign_multiple_select');
+}
+
+async function renderAssignEditor(engine: FlowEngine, action: FlowModel) {
+  const step = createAssignFieldValuesStep({ settingsFlowKey: 'assignSettings' });
+  const Editor = step.uiSchema().editor?.['x-component'] as React.ComponentType;
+  const flowSettingsCtx = new FlowRuntimeContext(action as any, 'assignSettings', 'settings');
+
+  render(
+    <FlowEngineProvider engine={engine}>
+      <ConfigProvider>
+        <App>
+          <FlowSettingsContextProvider value={flowSettingsCtx}>
+            <Editor />
+          </FlowSettingsContextProvider>
+        </App>
+      </ConfigProvider>
+    </FlowEngineProvider>,
+  );
+}
+
+describe('assignFieldValuesFlow multipleSelect', () => {
+  it('renders multipleSelect as multi select and normalizes historical scalar values', async () => {
+    const engine = createEngine();
+    const collection = addMultipleSelectCollection(engine);
+
+    const action = engine.createModel({ use: 'FlowModel', uid: 'act-assign-multiple-select' });
+    action.setStepParams('assignSettings', 'assignFieldValues', {
+      assignedValues: {
+        tags: 'a',
+        legacyTags: 'c',
+        tagMode: 't',
+        single: 'x',
+        nickname: 'hello',
+      },
+    });
+    action.context.defineProperty('blockModel', { value: { collection } });
+
+    const tempFields: any[] = [];
+    const originalCreateModel = engine.createModel.bind(engine);
+    (engine as any).createModel = (options: any) => {
+      const model = originalCreateModel(options);
+      if (options?.use === 'VariableFieldFormModel') {
+        tempFields.push(model);
+      }
+      return model;
+    };
+
+    await renderAssignEditor(engine, action);
+
+    await waitFor(() => {
+      const form = engine.findModelByParentId<AssignFormModel>(action.uid, 'assignForm');
+      expect(form?.subModels.grid.subModels.items || []).toHaveLength(5);
+    });
+
+    const form = engine.findModelByParentId<AssignFormModel>(action.uid, 'assignForm');
+    await waitFor(() => {
+      expect(form?.getAssignedValues()).toEqual({
+        tags: ['a'],
+        legacyTags: ['c'],
+        tagMode: ['t'],
+        single: 'x',
+        nickname: 'hello',
+      });
+    });
+
+    await waitFor(() => {
+      // All three multipleSelect fields must render as antd multi select, including the
+      // field without schema `mode`; the normal select stays single.
+      expect(document.querySelectorAll('.ant-select-multiple')).toHaveLength(3);
+      expect(document.querySelectorAll('.ant-select-single').length).toBeGreaterThanOrEqual(1);
+    });
+
+    const findTempField = (fieldPath: string) =>
+      tempFields
+        .map((root) => root?.subModels?.fields?.[0])
+        .find((field) => field?.getStepParams?.('fieldSettings', 'init')?.fieldPath === fieldPath);
+    await waitFor(() => {
+      expect(findTempField('tags')?.props?.onChange).toBeTypeOf('function');
+      expect(findTempField('tags')?.props?.mode).toBe('multiple');
+      expect(findTempField('legacyTags')?.props?.mode).toBe('multiple');
+      // An explicit schema mode must be preserved by the fallback.
+      expect(findTempField('tagMode')?.props?.mode).toBe('tags');
+    });
+
+    findTempField('tags').props.onChange(['a', 'b']);
+    await waitFor(() => {
+      expect(form?.getAssignedValues()).toMatchObject({ tags: ['a', 'b'], single: 'x' });
+    });
+
+    findTempField('tags').props.onChange('');
+    await waitFor(() => {
+      expect(form?.getAssignedValues()).toMatchObject({ tags: [] });
+    });
+  });
+});

package/src/flow/models/blocks/assign-form/__tests__/assignFormValue.test.ts

@@ -0,0 +1,41 @@
+/**
+ * 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 { isArrayValueField, normalizeAssignFormValue } from '../assignFormValue';
+
+describe('assignFormValue', () => {
+  it('detects array-valued fields', () => {
+    expect(isArrayValueField({ interface: 'multipleSelect' })).toBe(true);
+    expect(isArrayValueField({ interface: 'checkboxGroup' })).toBe(true);
+    expect(isArrayValueField({ uiSchema: { type: 'array' } })).toBe(true);
+    expect(isArrayValueField({ interface: 'select', uiSchema: { type: 'string' } })).toBe(false);
+    expect(isArrayValueField(undefined)).toBe(false);
+  });
+
+  it('wraps scalar constants for array fields', () => {
+    expect(normalizeAssignFormValue('a', true)).toEqual(['a']);
+    expect(normalizeAssignFormValue(0, true)).toEqual([0]);
+    expect(normalizeAssignFormValue(false, true)).toEqual([false]);
+    expect(normalizeAssignFormValue(['a', 'b'], true)).toEqual(['a', 'b']);
+  });
+
+  it('keeps non-constant and empty values unchanged', () => {
+    expect(normalizeAssignFormValue('', true)).toEqual([]);
+    expect(normalizeAssignFormValue(null, true)).toBeNull();
+    expect(normalizeAssignFormValue(undefined, true)).toBeUndefined();
+    expect(normalizeAssignFormValue('{{ ctx.record.name }}', true)).toBe('{{ ctx.record.name }}');
+    expect(normalizeAssignFormValue({ code: 'return 1;' }, true)).toEqual({ code: 'return 1;' });
+  });
+
+  it('does not touch non-array fields', () => {
+    expect(normalizeAssignFormValue('a', false)).toBe('a');
+    expect(normalizeAssignFormValue(['a'], false)).toEqual(['a']);
+  });
+});

package/src/flow/models/blocks/assign-form/assignFormValue.ts

@@ -0,0 +1,64 @@
+/**
+ * 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 { isRunJSValue, isVariableExpression } from '@nocobase/flow-engine';
+
+type ArrayValueCollectionField =
+  | {
+      interface?: string;
+      uiSchema?: {
+        type?: string;
+      } | null;
+    }
+  | null
+  | undefined;
+
+/**
+ * Fields whose stored value is an array. Besides `multipleSelect`/`checkboxGroup`,
+ * some legacy fields declare `uiSchema.type === 'array'` explicitly.
+ */
+export function isArrayValueField(collectionField: ArrayValueCollectionField): boolean {
+  if (!collectionField) {
+    return false;
+  }
+  if (collectionField.interface === 'multipleSelect' || collectionField.interface === 'checkboxGroup') {
+    return true;
+  }
+  return collectionField.uiSchema?.type === 'array';
+}
+
+/**
+ * Normalize a constant assignment value for array-valued fields.
+ *
+ * Historical configurations may store a scalar (before the multi-select control
+ * was rendered correctly), so wrap it into an array instead of submitting a
+ * string to the server. Variable expressions, RunJS values, Null and empty
+ * values are kept as-is so the assignment mode is not changed.
+ */
+export function normalizeAssignFormValue(value: unknown, arrayValueField: boolean): unknown {
+  if (!arrayValueField) {
+    return value;
+  }
+  if (isVariableExpression(value) || isRunJSValue(value)) {
+    return value;
+  }
+  if (value === '') {
+    return [];
+  }
+  if (Array.isArray(value)) {
+    return value;
+  }
+  if (value === null || typeof value === 'undefined') {
+    return value;
+  }
+  if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+    return [value];
+  }
+  return value;
+}

package/src/flow/models/blocks/filter-form/__tests__/FilterFormGridModel.toggleFormFieldsCollapse.test.ts

@@ -21,6 +21,35 @@ describe('FilterFormGridModel.toggleFormFieldsCollapse', () => {
     engine.registerModels({ FilterFormGridModel });
   });
 
+  it.each([false, true])('preserves collapsed fields in mobile layout with settings enabled: %s', (settingsEnabled) => {
+    engine.flowSettings[settingsEnabled ? 'enable' : 'disable']();
+    const rows = {
+      first: [['field-1']],
+      second: [['field-2']],
+      third: [['field-3']],
+    };
+    const model = engine.createModel<FilterFormGridModel>({
+      uid: 'mobile-filter-grid',
+      use: 'FilterFormGridModel',
+      props: { rows },
+      subModels: {
+        items: ['field-1', 'field-2', 'field-3'].map((uid) => ({ use: 'FlowModel', uid })),
+      },
+    });
+    model.context.defineProperty('isMobileLayout', { value: true });
+    model.setStepParams(GRID_FLOW_KEY, GRID_STEP, { rows });
+    type VisibleLayoutReader = { getVisibleLayout(): { rows: Record<string, string[][]> } };
+    const renderedItems = () =>
+      Object.values((model as unknown as VisibleLayoutReader).getVisibleLayout().rows).flat(2);
+
+    expect(renderedItems()).toEqual(['field-1', 'field-2', 'field-3']);
+    model.toggleFormFieldsCollapse(true, 1);
+    expect(renderedItems()).toEqual(['field-1']);
+    model.toggleFormFieldsCollapse(false, 1);
+    expect(renderedItems()).toEqual(['field-1', 'field-2', 'field-3']);
+    expect(model.getStepParams(GRID_FLOW_KEY, GRID_STEP).rows).toEqual(rows);
+  });
+
   it('uses rowOrder from the full layout when collapsing after reorder', () => {
     const model = engine.createModel<FilterFormGridModel>({
       uid: 'filter-grid-collapse-order',

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

@@ -351,7 +351,7 @@ export const FieldComponentProps: React.FC<{ fieldModel: string; source: string[
       <FormItem label={t('Options')}>
         <Space direction="vertical" size={8} style={{ width: '100%' }}>
           {options.map((option: any, index: number) => (
-            <Space key={`${option.value}-${index}`} style={{ width: '100%' }} size={8} wrap align="start">
+            <Space key={index} style={{ width: '100%' }} size={8} wrap align="start">
               <Input
                 style={{ flex: 1, minWidth: 120 }}
                 placeholder={t('Option label')}

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

@@ -0,0 +1,61 @@
+/**
+ * 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 { describe, expect, it } from 'vitest';
+import { createForm } from '@formily/core';
+import { Field, FormProvider } from '@formily/react';
+import { render, screen } from '@nocobase/test/client';
+import userEvent from '@testing-library/user-event';
+import { FlowEngine, FlowEngineProvider, FlowModel, FlowModelProvider } from '@nocobase/flow-engine';
+import { FieldComponentProps } from '../FieldComponentProps';
+
+class HostModel extends FlowModel {
+  render() {
+    return null;
+  }
+}
+
+describe.each(['RadioGroupFieldModel', 'CheckboxGroupFieldModel', 'SelectFieldModel'])('%s options', (fieldModel) => {
+  it('keeps focus while editing option values and preserves remaining rows after removal', async () => {
+    const form = createForm();
+    const engine = new FlowEngine();
+    engine.registerModels({ HostModel });
+    const model = engine.createModel<HostModel>({ use: 'HostModel' });
+    render(
+      <FlowEngineProvider engine={engine}>
+        <FlowModelProvider model={model}>
+          <FormProvider form={form}>
+            <Field name="props" component={[FieldComponentProps, { fieldModel, source: [] }]} />
+          </FormProvider>
+        </FlowModelProvider>
+      </FlowEngineProvider>,
+    );
+
+    await userEvent.click(screen.getByRole('button', { name: 'plus Add' }));
+    const valueInput = screen.getByPlaceholderText('Option value');
+    await userEvent.type(valueInput, 'abcdef');
+    expect(screen.getByPlaceholderText('Option value')).toHaveValue('abcdef');
+    expect(valueInput).toHaveFocus();
+
+    await userEvent.keyboard('{Backspace}{Backspace}xy');
+    expect(valueInput).toHaveValue('abcdxy');
+    expect(valueInput).toHaveFocus();
+    await userEvent.type(screen.getByPlaceholderText('Option label'), 'First');
+    await userEvent.click(screen.getByRole('button', { name: 'plus Add' }));
+    await userEvent.type(screen.getAllByPlaceholderText('Option label')[1], 'Second');
+    await userEvent.type(screen.getAllByPlaceholderText('Option value')[1], 'second');
+    await userEvent.click(screen.getAllByRole('button', { name: 'close' })[0]);
+    expect(screen.getByPlaceholderText('Option label')).toHaveValue('Second');
+    expect(screen.getByPlaceholderText('Option value')).toHaveValue('second');
+    await userEvent.type(screen.getByPlaceholderText('Option value'), '2');
+    expect(screen.getByPlaceholderText('Option value')).toHaveFocus();
+    expect(form.values.props.options).toEqual([{ label: 'Second', value: 'second2' }]);
+  });
+});

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

@@ -399,20 +399,41 @@ export class FormBlockModel<
           if (Array.isArray(topValue) && topValue.length === 0) return false;
 
           // 本地优先：支持对多关系的 dot 聚合路径（例如 assignees.name）。
-          // lodash.get 对数组聚合路径会返回 undefined（如 _.get({ assignees:[{name:'A'}] }, 'assignees.name')），
-          // 因而这里先用 getValuesByPath 做一次前端可解析性检查，命中则直接前端解析。
+          // 关联字段只有在本地值包含目标标题字段时才算完整；标量外键或仅含主键的轻量对象仍需服务端补全。
           const formValuesSnapshot = runtime.getFormValuesSnapshot();
+          let shouldResolveAssociationValueOnServer = false;
           if (formValuesSnapshot && typeof formValuesSnapshot === 'object') {
-            const localResolved = getValuesByPath(formValuesSnapshot as Record<string, any>, subPath);
+            const localResolved = getValuesByPath(formValuesSnapshot as Record<string, unknown>, subPath);
             if (typeof localResolved !== 'undefined') {
-              return false;
+              const fieldPath = subPath
+                .replace(/\[\d+\]/g, '')
+                .split('.')
+                .filter((segment) => !/^\d+$/.test(segment))
+                .join('.');
+              const resolvedField = this.collection?.getFieldByPath?.(fieldPath);
+              const titleFieldName = resolvedField?.targetCollectionTitleFieldName;
+              const isLoadedAssociationRecord = (value: unknown) => {
+                if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+                if (!titleFieldName) return true;
+                return typeof (value as Record<string, unknown>)[titleFieldName] !== 'undefined';
+              };
+              const isAssociationValueLoaded =
+                localResolved === null ||
+                (Array.isArray(localResolved)
+                  ? localResolved.length === 0 ||
+                    localResolved.every((value) => value === null || isLoadedAssociationRecord(value))
+                  : isLoadedAssociationRecord(localResolved));
+              if (!resolvedField?.isAssociationField?.() || isAssociationValueLoaded) {
+                return false;
+              }
+              shouldResolveAssociationValueOnServer = true;
             }
           }
 
           // 已配置字段：仅关联字段的子路径按需服务端补全（保持现有语义）
           const assocResolver = createAssociationSubpathResolver(
             () => this.collection,
-            () => runtime.getFormValuesSnapshot(),
+            shouldResolveAssociationValueOnServer ? undefined : () => runtime.getFormValuesSnapshot(),
           );
           return assocResolver(subPath);
         }

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

@@ -23,6 +23,7 @@ import {
 } from '@nocobase/flow-engine';
 import { Button, Form, Skeleton, Space } from 'antd';
 import React from 'react';
+import { findDataScopeStep, getQuickEditDataScopeFilter } from '../../../internal/utils/quickEditDataScope';
 import { FieldModel } from '../../base/FieldModel';
 import { FormComponent } from './FormBlockModel';
 import { FormItemModel } from './FormItemModel';
@@ -36,6 +37,14 @@ const QUICK_EDIT_MOBILE_CONTENT_PADDING = '8px var(--nb-mobile-page-tabs-content
 const QUICK_EDIT_MOBILE_ACTIONS_PADDING =
   '8px var(--nb-mobile-page-tabs-content-padding, 12px) calc(80px + env(safe-area-inset-bottom, 0px))';
 const QUICK_EDIT_MOBILE_MEDIA_QUERY = '(max-width: 768px)';
+// Dropdown-style editors open upwards inside the desktop popover so the option list does not cover the Submit and
+// Cancel buttons rendered right below the field. antd still flips the list downwards when there is no room above.
+const QUICK_EDIT_DROPDOWN_UP_MODELS = [
+  'SelectFieldModel',
+  'RecordSelectFieldModel',
+  'CascadeSelectFieldModel',
+  'CascadeSelectListFieldModel',
+];
 
 type QuickEditViewBeforeClosePayload = {
   result?: unknown;
@@ -159,6 +168,7 @@ export class QuickEditFormModel extends FlowModel {
   __onSubmitSuccess;
   _fieldProps: any;
   _onOk: any;
+  _dataScopeFilter: Record<string, any> | undefined;
 
   get form() {
     return this.context.form;
@@ -212,6 +222,7 @@ export class QuickEditFormModel extends FlowModel {
       },
       sourceFieldModel ? { delegate: sourceFieldModel.context } : undefined,
     ) as QuickEditFormModel;
+    model._dataScopeFilter = getQuickEditDataScopeFilter(sourceFieldModel);
 
     const bodyStyles = {
       maxHeight: QUICK_EDIT_POPOVER_MAX_HEIGHT,
@@ -410,6 +421,13 @@ QuickEditFormModel.registerFlow({
         resource.setDataSourceKey(dataSourceKey);
         resource.setResourceName(collectionName);
         ctx.model.resource = resource;
+        // Seed the edited row before dispatching the field model's flows. An association data scope resolves
+        // `ctx.record` while the field renders, and so does the foreign key filter that one-to-one and one-to-many
+        // editors build, so the record has to be in place first.
+        if (ctx.inputArgs.filterByTk || ctx.inputArgs.record) {
+          resource.setFilterByTk(ctx.inputArgs.filterByTk);
+          resource.setData(ctx.inputArgs.record);
+        }
         const collectionField = ctx.model.collection.getField(fieldPath) as CollectionField;
         if (collectionField) {
           const binding = FormItemModel.getDefaultBindingByField(ctx, collectionField);
@@ -417,24 +435,42 @@ QuickEditFormModel.registerFlow({
             return;
           }
           const use = binding.modelName;
+          const stepParams: Record<string, Record<string, Record<string, unknown>>> = {
+            fieldSettings: {
+              init: {
+                dataSourceKey,
+                collectionName,
+                fieldPath,
+              },
+            },
+          };
+          const dataScopeFilter = ctx.model._dataScopeFilter;
+          if (dataScopeFilter) {
+            const dataScopeStep = findDataScopeStep(ctx.engine.getModelClass(use));
+            if (dataScopeStep) {
+              stepParams[dataScopeStep.flowKey] = {
+                ...stepParams[dataScopeStep.flowKey],
+                [dataScopeStep.stepKey]: { filter: dataScopeFilter },
+              };
+            }
+          }
           const fieldModel = ctx.model.addSubModel<FieldModel>('fields', {
             use,
             props:
               typeof binding.defaultProps === 'function'
                 ? binding.defaultProps(ctx, collectionField)
                 : binding.defaultProps,
-            stepParams: {
-              fieldSettings: {
-                init: {
-                  dataSourceKey,
-                  collectionName,
-                  fieldPath,
-                },
-              },
-            },
+            stepParams,
           });
           fieldModel.setProps(getQuickEditFieldProps(collectionField, ctx.model._fieldProps));
           fieldModel.setProps({ sourceFieldModelUid: ctx.inputArgs.sourceFieldModelUid });
+          if (
+            !ctx.model.context.isMobileLayout &&
+            QUICK_EDIT_DROPDOWN_UP_MODELS.includes(use) &&
+            fieldModel.props.placement == null
+          ) {
+            fieldModel.setProps({ placement: 'topLeft' });
+          }
           ctx.model.context.defineProperty('collectionField', {
             get: () => collectionField,
           });
@@ -442,8 +478,6 @@ QuickEditFormModel.registerFlow({
           await fieldModel.dispatchEvent('beforeRender');
         }
         if (ctx.inputArgs.filterByTk || ctx.inputArgs.record) {
-          resource.setFilterByTk(ctx.inputArgs.filterByTk);
-          resource.setData(ctx.inputArgs.record);
           ctx.model.form?.setFieldsValue(resource.getData());
         }
       },