@nocobase/client-v2 2.1.0-beta.34 → 2.1.0-beta.36

package/src/flow/models/blocks/filter-form/__tests__/defaultValues.wiring.test.ts

@@ -7,10 +7,97 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
+import React from 'react';
+import { render, waitFor } from '@testing-library/react';
+import { FlowEngine } from '@nocobase/flow-engine';
 import { describe, expect, it, vi } from 'vitest';
 import { filterFormDefaultValues } from '../../../../actions/filterFormDefaultValues';
 import { FilterFormBlockModel } from '../FilterFormBlockModel';
 
+function resolveTemplateValue(raw: any, values: Record<string, any>): any {
+  if (typeof raw === 'string') {
+    const matched = raw.match(/^\{\{\s*ctx\.formValues\.([^}]+?)\s*\}\}$/);
+    return matched ? values[matched[1]] : raw;
+  }
+  if (Array.isArray(raw)) {
+    return raw.map((item) => resolveTemplateValue(item, values));
+  }
+  if (raw && typeof raw === 'object') {
+    return Object.fromEntries(Object.entries(raw).map(([key, value]) => [key, resolveTemplateValue(value, values)]));
+  }
+  return raw;
+}
+
+function createFilterFormDefaultValuesModel(rules: any[], initialValues: Record<string, any> = {}) {
+  const values = { ...initialValues };
+  const createItem = (fieldPath: string, uid: string) => ({
+    uid,
+    fieldPath,
+    props: { name: `${fieldPath}_${uid}` },
+    getProps() {
+      return this.props;
+    },
+    getStepParams(flowKey: string, stepKey: string) {
+      if (flowKey === 'fieldSettings' && stepKey === 'init') {
+        return { fieldPath };
+      }
+      return undefined;
+    },
+    subModels: {
+      field: {},
+    },
+  });
+  const model = {
+    defaultValuesRefreshSeq: 0,
+    lastDefaultValueByFieldName: new Map<string, any>(),
+    form: {
+      getFieldsValue: () => ({ ...values }),
+      getFieldValue: (name: string) => values[name],
+      setFieldValue: (name: string, value: any) => {
+        values[name] = value;
+      },
+      setFieldsValue: (next: Record<string, any>) => {
+        Object.assign(values, next);
+      },
+    },
+    context: {
+      resolveJsonTemplate: vi.fn((raw) => resolveTemplateValue(raw, values)),
+      app: {
+        jsonLogic: {
+          apply: vi.fn((logic: Record<string, any[]>) => {
+            const [[operator, args]] = Object.entries(logic);
+            if (operator === '$eq') return args[0] === args[1];
+            return true;
+          }),
+        },
+      },
+    },
+    subModels: {
+      grid: {
+        subModels: {
+          items: [createItem('nickname', 'nick'), createItem('username', 'user')],
+        },
+      },
+    },
+    getStepParams: vi.fn((flowKey: string, stepKey: string) => {
+      if (flowKey === 'formFilterBlockModelSettings' && stepKey === 'defaultValues') {
+        return { value: rules };
+      }
+      return undefined;
+    }),
+    canApplyFormDefaultValue: (FilterFormBlockModel.prototype as any).canApplyFormDefaultValue,
+    matchDefaultValueCondition: (FilterFormBlockModel.prototype as any).matchDefaultValueCondition,
+    applyFormDefaultValues: FilterFormBlockModel.prototype.applyFormDefaultValues,
+    handleFilterFormValuesChange: (FilterFormBlockModel.prototype as any).handleFilterFormValuesChange,
+    dispatchEvent: vi.fn(),
+    emitter: {
+      emit: vi.fn(),
+    },
+  };
+
+  return { model, values };
+}
+
 describe('filter-form defaultValues wiring', () => {
   it('loads action and model modules', () => {
     expect(filterFormDefaultValues).toBeTruthy();
@@ -48,4 +135,254 @@ describe('filter-form defaultValues wiring', () => {
     expect(model.initialDefaultsPromise).toBeUndefined();
     expect(model.applyFormDefaultValues).not.toHaveBeenCalled();
   });
+
+  it('exposes current form values in the filter form variable meta tree', async () => {
+    const engine = new FlowEngine();
+
+    const dataSource = engine.context.dataSourceManager.getDataSource('main');
+    dataSource.addCollection({
+      name: 'users',
+      filterTargetKey: ['id', 'tenantId'],
+      fields: [
+        { name: 'id', type: 'integer', interface: 'number' },
+        { name: 'tenantId', type: 'string', interface: 'text' },
+        { name: 'name', type: 'string', interface: 'text' },
+      ],
+    });
+    dataSource.addCollection({
+      name: 'departments',
+      filterTargetKey: 'id',
+      fields: [
+        { name: 'id', type: 'integer', interface: 'number' },
+        { name: 'name', type: 'string', interface: 'text' },
+        { name: 'owner', type: 'belongsTo', target: 'users', interface: 'm2o' },
+      ],
+    });
+    dataSource.addCollection({
+      name: 'tasks',
+      filterTargetKey: 'id',
+      fields: [
+        { name: 'id', type: 'integer', interface: 'number' },
+        { name: 'title', type: 'string', interface: 'text' },
+        { name: 'department', type: 'belongsTo', target: 'departments', interface: 'm2o' },
+      ],
+    });
+
+    engine.registerModels({ FilterFormBlockModel });
+    const model = engine.createModel<FilterFormBlockModel>({
+      use: 'FilterFormBlockModel',
+      uid: 'filter-form-current-form',
+      subModels: {
+        grid: {
+          subModels: {
+            items: [],
+          },
+        },
+      },
+    } as any);
+
+    function HookCaller() {
+      model.useHooksBeforeRender();
+      return null;
+    }
+
+    render(React.createElement(HookCaller));
+
+    const store = {
+      title: 'bug',
+      'department_department-filter': 1,
+      'department.owner_owner-filter': { id: 7, tenantId: 'tenant-a' },
+    };
+    const fakeForm = {
+      getFieldsValue: () => ({ ...store }),
+    };
+    model.context.defineProperty('form', { value: fakeForm });
+    model.subModels.grid.subModels.items = [
+      {
+        uid: 'department-filter',
+        fieldPath: 'department',
+        props: { name: 'department_department-filter' },
+        subModels: {
+          field: {
+            context: {
+              collectionField: dataSource.getCollection('tasks').getField('department'),
+            },
+          },
+        },
+      },
+      {
+        uid: 'owner-filter',
+        fieldPath: 'department.owner',
+        props: { name: 'department.owner_owner-filter' },
+        subModels: {
+          field: {
+            context: {
+              collectionField: dataSource.getCollection('departments').getField('owner'),
+            },
+          },
+        },
+      },
+    ];
+
+    expect((model.context as any).formValues).toMatchObject({
+      ...store,
+      department: {
+        'owner_owner-filter': { id: 7, tenantId: 'tenant-a' },
+      },
+    });
+
+    const options = (model.context as any).getPropertyOptions('formValues');
+    const meta = await options.meta();
+    const properties = await meta.properties();
+    const metaTree = await (model.context as any).getPropertyMetaTree();
+
+    expect(options.resolveOnServer('department_department-filter')).toBe(false);
+    expect(options.resolveOnServer('department_department-filter.name')).toBe(true);
+    expect(options.resolveOnServer('department_department-filter[0].name')).toBe(true);
+    expect(options.resolveOnServer('department.owner_owner-filter.name')).toBe(true);
+    expect(options.serverOnlyWhenContextParams).toBe(true);
+    expect(meta.title).toBe('Current form');
+    expect(properties.department.properties['owner_owner-filter'].title).toBe('owner');
+    expect(metaTree).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          name: 'formValues',
+          title: 'Current form',
+        }),
+      ]),
+    );
+    expect(await meta.buildVariablesParams(model.context)).toMatchObject({
+      'department_department-filter': { collection: 'departments', dataSourceKey: 'main', filterByTk: 1 },
+      department: {
+        'owner_owner-filter': {
+          collection: 'users',
+          dataSourceKey: 'main',
+          filterByTk: { id: 7, tenantId: 'tenant-a' },
+        },
+      },
+    });
+  });
+
+  it('refreshes default values that depend on current filter form values', async () => {
+    const { model, values } = createFilterFormDefaultValuesModel(
+      [
+        {
+          key: 'username-default',
+          enable: true,
+          targetPath: 'username',
+          mode: 'default',
+          value: '{{ ctx.formValues.nickname_nick }}',
+        },
+      ],
+      { nickname_nick: 'Alice' },
+    );
+
+    await FilterFormBlockModel.prototype.applyFormDefaultValues.call(model as any);
+    expect(values.username_user).toBe('Alice');
+
+    values.nickname_nick = 'Bob';
+    model.defaultValuesRefreshSeq += 1;
+    await FilterFormBlockModel.prototype.applyFormDefaultValues.call(model as any, {
+      refreshSeq: model.defaultValuesRefreshSeq,
+    });
+    expect(values.username_user).toBe('Bob');
+
+    values.username_user = 'Manual';
+    values.nickname_nick = 'Carol';
+    model.defaultValuesRefreshSeq += 1;
+    await FilterFormBlockModel.prototype.applyFormDefaultValues.call(model as any, {
+      refreshSeq: model.defaultValuesRefreshSeq,
+    });
+    expect(values.username_user).toBe('Manual');
+  });
+
+  it('applies fixed values even when the target filter field already has a value', async () => {
+    const { model, values } = createFilterFormDefaultValuesModel(
+      [
+        {
+          key: 'username-fixed',
+          enable: true,
+          targetPath: 'username',
+          mode: 'assign',
+          value: '{{ ctx.formValues.nickname_nick }}',
+        },
+      ],
+      { nickname_nick: 'Bob', username_user: 'Manual' },
+    );
+
+    await FilterFormBlockModel.prototype.applyFormDefaultValues.call(model as any);
+
+    expect(values.username_user).toBe('Bob');
+  });
+
+  it('skips filter form field values when the rule condition does not match', async () => {
+    const { model, values } = createFilterFormDefaultValuesModel(
+      [
+        {
+          key: 'username-condition',
+          enable: true,
+          targetPath: 'username',
+          mode: 'assign',
+          condition: {
+            logic: '$and',
+            items: [{ path: '{{ ctx.formValues.nickname_nick }}', operator: '$eq', value: 'allow' }],
+          },
+          value: 'Matched',
+        },
+      ],
+      { nickname_nick: 'deny' },
+    );
+
+    await FilterFormBlockModel.prototype.applyFormDefaultValues.call(model as any);
+    expect(values.username_user).toBeUndefined();
+
+    values.nickname_nick = 'allow';
+    await FilterFormBlockModel.prototype.applyFormDefaultValues.call(model as any);
+    expect(values.username_user).toBe('Matched');
+  });
+
+  it('emits formValuesChange with final values after applying dependent field values', async () => {
+    const { model, values } = createFilterFormDefaultValuesModel(
+      [
+        {
+          key: 'username-fixed',
+          enable: true,
+          targetPath: 'username',
+          mode: 'assign',
+          value: '{{ ctx.formValues.nickname_nick }}',
+        },
+      ],
+      { nickname_nick: 'Bob' },
+    );
+
+    (model as any).handleFilterFormValuesChange({ nickname_nick: 'Bob' }, { nickname_nick: 'Bob' });
+
+    await waitFor(() => {
+      expect(values.username_user).toBe('Bob');
+      expect(model.dispatchEvent).toHaveBeenCalledWith(
+        'formValuesChange',
+        {
+          changedValues: {
+            nickname_nick: 'Bob',
+            username_user: 'Bob',
+          },
+          allValues: {
+            nickname_nick: 'Bob',
+            username_user: 'Bob',
+          },
+        },
+        { debounce: true },
+      );
+    });
+    expect(model.emitter.emit).toHaveBeenCalledWith('formValuesChange', {
+      changedValues: {
+        nickname_nick: 'Bob',
+        username_user: 'Bob',
+      },
+      allValues: {
+        nickname_nick: 'Bob',
+        username_user: 'Bob',
+      },
+    });
+  });
 });

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

@@ -24,6 +24,7 @@ import { EditFormModel } from './EditFormModel';
 import _ from 'lodash';
 import { Tooltip } from 'antd';
 import { coerceForToOneField } from '../../../internal/utils/associationValueCoercion';
+import { getFormItemFieldPathCandidates } from '../../../internal/utils/modelUtils';
 import { buildDynamicNamePath } from './dynamicNamePath';
 
 const interfacesOfUnsupportedDefaultValue = [
@@ -57,10 +58,9 @@ export class FormItemModel<T extends DefaultStructure = DefaultStructure> extend
           key: fullName,
           label: field.title,
           // 同步刷新 JS 字段菜单的切换状态（兼容旧路径与新路径）
-          refreshTargets: ['FormItemModel/FormJSFieldItemModel'],
+          refreshTargets: ['FormJSFieldItemModel', 'FormItemModel/FormJSFieldItemModel'],
           toggleable: (subModel) => {
-            const fieldPath = subModel.getStepParams('fieldSettings', 'init')?.fieldPath;
-            return fieldPath === fullName;
+            return getFormItemFieldPathCandidates(subModel).some((fieldPath) => fieldPath === fullName);
           },
           useModel: 'FormItemModel',
           createModelOptions: () => ({
@@ -183,6 +183,8 @@ export class FormItemModel<T extends DefaultStructure = DefaultStructure> extend
 
 FormItemModel.define({
   label: tExpr('Display fields'),
+  searchable: true,
+  searchPlaceholder: tExpr('Search fields'),
   sort: 100,
 });
 

package/src/flow/models/blocks/form/__tests__/FormItemModel.defineChildren.test.ts

@@ -0,0 +1,108 @@
+/**
+ * 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 { FlowEngine, type FlowModelContext, type SubModelItem } from '@nocobase/flow-engine';
+// Import from the aggregate to preserve the model initialization order used by adjacent tests.
+import { FormItemModel, FormJSFieldItemModel, InputFieldModel, JSEditableFieldModel } from '../../../..';
+
+function createFormMenuContext(prefixFieldPath = 'roles') {
+  const engine = new FlowEngine();
+  engine.registerModels({
+    FormItemModel,
+    FormJSFieldItemModel,
+    InputFieldModel,
+    JSEditableFieldModel,
+  });
+
+  const dataSource = engine.dataSourceManager.getDataSource('main');
+  dataSource.addCollection({
+    name: 'users',
+    filterTargetKey: 'id',
+    fields: [
+      { name: 'id', type: 'integer', interface: 'number', title: 'ID' },
+      { name: 'roles', type: 'hasMany', interface: 'o2m', target: 'roles', title: 'Roles' },
+    ],
+  });
+  dataSource.addCollection({
+    name: 'roles',
+    filterTargetKey: 'id',
+    fields: [
+      { name: 'id', type: 'integer', interface: 'number', title: 'ID' },
+      { name: 'name', type: 'string', interface: 'input', title: 'Name' },
+    ],
+  });
+
+  const blockModel = engine.createModel({ use: 'FlowModel', uid: 'users-form-block' });
+  (blockModel as any).collection = dataSource.getCollection('users');
+
+  const gridModel = engine.createModel({ use: 'FlowModel', uid: 'users-form-grid' });
+  gridModel.context.defineProperty('blockModel', { value: blockModel });
+  gridModel.context.defineProperty('collection', { value: dataSource.getCollection('roles') });
+  gridModel.context.defineProperty('prefixFieldPath', { value: prefixFieldPath });
+
+  return gridModel.context as FlowModelContext;
+}
+
+async function resolveCreateOptions(item: SubModelItem, ctx: FlowModelContext) {
+  return typeof item.createModelOptions === 'function' ? await item.createModelOptions(ctx) : item.createModelOptions;
+}
+
+function createModelLike(createOptions: any) {
+  return {
+    getStepParams: (flowKey: string, stepKey: string) => createOptions?.stepParams?.[flowKey]?.[stepKey],
+  } as any;
+}
+
+describe('FormItemModel defineChildren', () => {
+  it('refreshes the JS field submenu when a normal subform field is toggled', () => {
+    const ctx = createFormMenuContext();
+    const formItems = FormItemModel.defineChildren(ctx) as SubModelItem[];
+    const nameItem = formItems.find((item) => item.key === 'roles.name');
+
+    expect(nameItem?.refreshTargets).toEqual(['FormJSFieldItemModel', 'FormItemModel/FormJSFieldItemModel']);
+  });
+
+  it('recognizes JS subform fields that store associationPathName and fieldPath separately', async () => {
+    const ctx = createFormMenuContext();
+    const formItems = FormItemModel.defineChildren(ctx) as SubModelItem[];
+    const jsItems = (await FormJSFieldItemModel.defineChildren(ctx)) as SubModelItem[];
+    const normalNameItem = formItems.find((item) => item.key === 'roles.name');
+    const jsNameItem = jsItems.find((item) => item.key === 'roles.name');
+
+    expect(normalNameItem).toBeTruthy();
+    expect(jsNameItem).toBeTruthy();
+
+    const jsCreateOptions = await resolveCreateOptions(jsNameItem, ctx);
+    expect(jsCreateOptions?.stepParams?.fieldSettings?.init).toMatchObject({
+      associationPathName: 'roles',
+      fieldPath: 'name',
+    });
+
+    expect((normalNameItem?.toggleable as (model: any) => boolean)(createModelLike(jsCreateOptions))).toBe(true);
+  });
+
+  it('lets the JS subform menu recognize normal fields that store the full fieldPath', async () => {
+    const ctx = createFormMenuContext();
+    const formItems = FormItemModel.defineChildren(ctx) as SubModelItem[];
+    const jsItems = (await FormJSFieldItemModel.defineChildren(ctx)) as SubModelItem[];
+    const normalNameItem = formItems.find((item) => item.key === 'roles.name');
+    const jsNameItem = jsItems.find((item) => item.key === 'roles.name');
+
+    expect(normalNameItem).toBeTruthy();
+    expect(jsNameItem).toBeTruthy();
+
+    const normalCreateOptions = await resolveCreateOptions(normalNameItem, ctx);
+    expect(normalCreateOptions?.stepParams?.fieldSettings?.init).toMatchObject({
+      fieldPath: 'roles.name',
+    });
+
+    expect((jsNameItem?.toggleable as (model: any) => boolean)(createModelLike(normalCreateOptions))).toBe(true);
+  });
+});

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

@@ -29,6 +29,10 @@ import { getRowKey } from './utils';
 import { FormBlockModel } from '../form/FormBlockModel';
 
 const recordIdentityByFork = new WeakMap<ForkFlowModel<any>, string>();
+const rowActionButtonTypeOptions = [
+  { value: 'link', label: '{{t("Link")}}' },
+  { value: 'text', label: '{{t("Text")}}' },
+];
 
 const Columns = observer<any>(({ record, model, index }) => {
   const isConfigMode = !!model.context.flowSettingsEnabled;
@@ -65,6 +69,7 @@ const Columns = observer<any>(({ record, model, index }) => {
           }
 
           const fork = action.createFork({}, slotKey);
+          (fork as any).buttonTypeOptions = rowActionButtonTypeOptions;
           recordIdentityByFork.set(fork, recordIdentity);
 
           fork.invalidateFlowCache('beforeRender');

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

@@ -327,6 +327,8 @@ export class TableColumnModel extends DisplayItemModel {
 
 TableColumnModel.define({
   label: tExpr('Display fields'),
+  searchable: true,
+  searchPlaceholder: tExpr('Search fields'),
 });
 
 TableColumnModel.registerFlow({

package/src/flow/models/fields/AssociationFieldModel/SubTableFieldModel/SubTableColumnModel.tsx

@@ -1050,4 +1050,6 @@ SubTableColumnModel.registerFlow({
 SubTableColumnModel.define({
   hide: true,
   label: tExpr('Table column'),
+  searchable: true,
+  searchPlaceholder: tExpr('Search fields'),
 });