@nocobase/client-v2 2.2.30 → 2.2.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/client-v2",
-  "version": "2.2.30",
+  "version": "2.2.32",
   "license": "Apache-2.0",
   "main": "lib/index.js",
   "module": "es/index.mjs",
@@ -27,11 +27,11 @@
     "@formily/antd-v5": "1.2.3",
     "@formily/react": "^2.2.27",
     "@formily/shared": "^2.2.27",
-    "@nocobase/evaluators": "2.2.30",
-    "@nocobase/flow-engine": "2.2.30",
-    "@nocobase/sdk": "2.2.30",
-    "@nocobase/shared": "2.2.30",
-    "@nocobase/utils": "2.2.30",
+    "@nocobase/evaluators": "2.2.32",
+    "@nocobase/flow-engine": "2.2.32",
+    "@nocobase/sdk": "2.2.32",
+    "@nocobase/shared": "2.2.32",
+    "@nocobase/utils": "2.2.32",
     "ahooks": "^3.7.2",
     "antd": "5.24.2",
     "antd-style": "3.7.1",
@@ -49,5 +49,5 @@
     "react-router-dom": "^6.30.1",
     "zxing-wasm": "^3.1.3"
   },
-  "gitHead": "7042ebef45742005aa38cd78c366e3e7f4ffed52"
+  "gitHead": "04fa0d6f0fbc637f59a1c8a40a7ce038e13d267c"
 }

package/src/flow/models/blocks/assign-form/AssignFormItemModel.tsx

@@ -31,6 +31,7 @@ import {
   isDateLikeField,
   resolveDateVariableComponentProps,
 } from '../../../components/field-value-variable';
+import { isArrayValueField, normalizeAssignFormValue } from './assignFormValue';
 
 type AssignFormTempOriginField = {
   uid?: string;
@@ -112,8 +113,6 @@ export class AssignFormItemModel extends FormItemModel {
   }
 
   onInit(options: any) {
-    const initAssign = this.getStepParams('fieldSettings', 'assignValue')?.value;
-    if (typeof initAssign !== 'undefined') this.assignValue = initAssign;
     this.context.defineProperty('collectionField', {
       get: () => {
         const params = this.getStepParams('fieldSettings', 'init') || {};
@@ -122,6 +121,10 @@ export class AssignFormItemModel extends FormItemModel {
         return dsm?.getCollectionField?.(key);
       },
     });
+    const initAssign = this.getStepParams('fieldSettings', 'assignValue')?.value;
+    if (typeof initAssign !== 'undefined') {
+      this.assignValue = normalizeAssignFormValue(initAssign, isArrayValueField(this.collectionField));
+    }
 
     // 确保存在 subModels.field，便于沿用 FormItemModel 的组件切换/设置步骤（fieldComponent 等）
     const ctx: any = this.context;
@@ -168,7 +171,7 @@ export class AssignFormItemModel extends FormItemModel {
   getAssignedEntry(): [string, any] | null {
     const name = this.fieldPath;
     if (!name || !this.collectionField) return null;
-    return [name, this.assignValue];
+    return [name, normalizeAssignFormValue(this.assignValue, isArrayValueField(this.collectionField))];
   }
 
   render() {
@@ -184,6 +187,7 @@ export class AssignFormItemModel extends FormItemModel {
     const fieldPath = this.fieldPath;
     const originField = this.subModels?.field as AssignFormTempOriginField | undefined;
     const tempFieldRefreshKey = getAssignFormTempFieldRefreshKey(originField);
+    const arrayValueField = isArrayValueField(this.collectionField);
 
     const FieldRow: React.FC = () => {
       const [tempRoot, setTempRoot] = React.useState<any>(null);
@@ -252,6 +256,14 @@ export class AssignFormItemModel extends FormItemModel {
         fm?.dispatchEvent?.('beforeRender', undefined, { sequential: true, useCache: true });
         // 为本地枚举型字段补全可选项（仅在未显式传入 options 时处理）
         ensureOptionsFromUiSchemaEnumIfAbsent(fm as any, cfForMultiple as any);
+        // `mode` is the antd Select switch for multi-select. It is normally injected by
+        // `collectionField.getComponentProps()`, which the temp field does not apply.
+        // Apply the fallback after `beforeRender` so field flows keep precedence; a
+        // schema-provided mode is used when present, otherwise default to `multiple`.
+        if (cfForMultiple?.interface === 'multipleSelect' && fm?.props?.mode === undefined) {
+          const schemaMode = cfForMultiple?.uiSchema?.['x-component-props']?.mode as string | undefined;
+          fm?.setProps?.({ mode: schemaMode ?? 'multiple' });
+        }
         if (!fm?.props?.fieldNames && cfForMultiple?.targetCollection) {
           const targetCol = cfForMultiple.targetCollection;
           const valueKey = cfForMultiple?.targetKey || targetCol?.filterTargetKey || 'id';
@@ -268,16 +280,17 @@ export class AssignFormItemModel extends FormItemModel {
       const ConstantValueEditor: React.FC<any> = (inputProps: any) => {
         React.useEffect(() => {
           if (!tempRoot) return;
+          const isArrayField = isArrayValueField(this.collectionField);
           // 同步根 props（变量输入的受控 value/onChange）
           tempRoot.setProps?.({ ...inputProps });
           // 同步到具体字段模型，确保字段组件能触发 onChange
           const fm = tempRoot?.subModels?.fields?.[0];
           if (fm) {
             fm.setProps?.({
-              value: inputProps?.value,
+              value: normalizeAssignFormValue(inputProps?.value, isArrayField),
               onChange: (...args: unknown[]) => {
                 const nextArg = args && args.length ? args[0] : undefined;
-                const nextValue = normalizeAssignFormInputValue(nextArg);
+                const nextValue = normalizeAssignFormValue(normalizeAssignFormInputValue(nextArg), isArrayField);
                 fm.setProps?.({ value: nextValue });
                 this.assignValue = nextValue;
                 inputProps?.onChange?.(nextValue);
@@ -330,20 +343,24 @@ export class AssignFormItemModel extends FormItemModel {
           {...this.props}
           label={labelText}
           name={namePath}
-          initialValue={this.assignValue}
+          initialValue={normalizeAssignFormValue(this.assignValue, arrayValueField)}
           valuePropName="__assign_value__"
           trigger="__assign_trigger__"
           validateTrigger="__assign_trigger__"
         >
           {React.createElement((formBindingProps: any) => {
             const formValue = formBindingProps?.__assign_value__;
-            const mergedValue = typeof formValue === 'undefined' ? this.assignValue : formValue;
+            const mergedValue = normalizeAssignFormValue(
+              typeof formValue === 'undefined' ? this.assignValue : formValue,
+              arrayValueField,
+            );
             return (
               <FieldValueVariableInput
                 value={mergedValue}
                 onChange={(v) => {
-                  this.assignValue = v;
-                  formBindingProps?.__assign_trigger__?.(v);
+                  const nextValue = normalizeAssignFormValue(v, arrayValueField);
+                  this.assignValue = nextValue;
+                  formBindingProps?.__assign_trigger__?.(nextValue);
                 }}
                 baseMetaTree={baseMetaTree}
                 constantComponent={ConstantValueEditor}

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;
+}