@nocobase/client-v2 2.2.0-beta.6 → 2.2.0-beta.8

package/src/flow/components/__tests__/fieldAssignOptions.test.ts

@@ -14,6 +14,15 @@ import {
   collectFieldAssignCascaderOptions,
 } from '../fieldAssignOptions';
 
+type TestCollectionField = {
+  name?: string;
+  title?: string;
+  interface?: string;
+  target?: string;
+  targetCollection?: unknown;
+  isAssociationField?: () => boolean;
+};
+
 describe('fieldAssignOptions', () => {
   it('marks subform node as non-leaf so Cascader can lazy-load target collection fields', () => {
     const usersCollection = {
@@ -98,8 +107,58 @@ describe('fieldAssignOptions', () => {
     ).toBe(true);
   });
 
+  it('preserves configured display association field paths as nested cascader options', () => {
+    const orgNameField = {
+      name: 'orgname',
+      title: '公司名称(单行文本)',
+      interface: 'input',
+      type: 'string',
+      isAssociationField: () => false,
+    };
+    const orgCollection = {
+      getFields: () => [orgNameField],
+      getField: (name: string) => (name === 'orgname' ? orgNameField : null),
+    };
+    const orgAssociationField = {
+      name: 'org_m2o',
+      title: 'org_m2o',
+      interface: 'm2o',
+      type: 'belongsTo',
+      target: 'org',
+      isAssociationField: () => true,
+      targetCollection: orgCollection,
+    };
+    const rootCollection = {
+      getField: (name: string) => (name === 'org_m2o' ? orgAssociationField : null),
+      getFields: () => [orgAssociationField],
+    };
+    const displayAssociationItemModel = {
+      props: { label: '公司名称(单行文本)' },
+      getStepParams: (flowKey: string, stepKey: string) => {
+        if (flowKey === 'fieldSettings' && stepKey === 'init') return { fieldPath: 'org_m2o.orgname' };
+        return {};
+      },
+      subModels: {
+        field: {
+          context: { collectionField: orgNameField },
+        },
+      },
+    };
+    const formBlockModel = {
+      context: { collection: rootCollection },
+      subModels: { grid: { subModels: { items: [displayAssociationItemModel] } } },
+    };
+
+    const options = collectFieldAssignCascaderOptions({ formBlockModel, t: (s) => s });
+    const orgOption = options.find((option) => option.value === 'org_m2o');
+
+    expect(orgOption?.isLeaf).toBe(false);
+    expect(orgOption?.children?.some((child) => child.value === 'orgname' && child.isLeaf === true)).toBe(true);
+    expect(options.some((option) => option.value === 'orgname')).toBe(false);
+  });
+
   it('hides configured association fields deeper than relation / relation / field', () => {
-    const makeItem = (fieldPath: string, field: any, label: string) => ({
+    const makeItem = (fieldPath: string, field: TestCollectionField, label: string) => ({
       props: { label },
       getStepParams: (flowKey: string, stepKey: string) => {
         if (flowKey === 'fieldSettings' && stepKey === 'init') return { fieldPath };
@@ -141,9 +200,98 @@ describe('fieldAssignOptions', () => {
     };
 
     const options = collectFieldAssignCascaderOptions({ formBlockModel, t: (s) => s });
+    const usersOption = options.find((item) => item.value === 'users');
+    const departmentOption = usersOption?.children?.find((item) => item.value === 'department');
+
+    expect(departmentOption?.children?.map((item) => item.value)).toContain('name');
+    expect(departmentOption?.children?.map((item) => item.value)).not.toContain('company');
+  });
+
+  it('hides configured non-association fields under a third association level', () => {
+    const codeField = {
+      name: 'code',
+      title: 'Code',
+      interface: 'input',
+      isAssociationField: () => false,
+    };
+    const companyCollection = {
+      getField: (name: string) => (name === 'code' ? codeField : null),
+      getFields: () => [codeField],
+    };
+    const companyField = {
+      name: 'company',
+      title: 'Company',
+      interface: 'm2o',
+      target: 'companies',
+      isAssociationField: () => true,
+      targetCollection: companyCollection,
+    };
+    const nameField = {
+      name: 'name',
+      title: 'Name',
+      interface: 'input',
+      isAssociationField: () => false,
+    };
+    const departmentCollection = {
+      getField: (name: string) => (name === 'name' ? nameField : name === 'company' ? companyField : null),
+      getFields: () => [nameField, companyField],
+    };
+    const departmentField = {
+      name: 'department',
+      title: 'Department',
+      interface: 'm2o',
+      target: 'departments',
+      isAssociationField: () => true,
+      targetCollection: departmentCollection,
+    };
+    const userCollection = {
+      getField: (name: string) => (name === 'department' ? departmentField : null),
+      getFields: () => [departmentField],
+    };
+    const usersField = {
+      name: 'users',
+      title: 'Users',
+      interface: 'm2m',
+      target: 'users',
+      isAssociationField: () => true,
+      targetCollection: userCollection,
+    };
+    const rootCollection = {
+      getField: (name: string) => (name === 'users' ? usersField : null),
+      getFields: () => [usersField],
+    };
+    const makeItem = (fieldPath: string, field: TestCollectionField, label: string) => ({
+      props: { label },
+      getStepParams: (flowKey: string, stepKey: string) => {
+        if (flowKey === 'fieldSettings' && stepKey === 'init') return { fieldPath };
+        return {};
+      },
+      subModels: {
+        field: {
+          context: { collectionField: field },
+        },
+      },
+    });
+    const formBlockModel = {
+      context: { collection: rootCollection },
+      subModels: {
+        grid: {
+          subModels: {
+            items: [
+              makeItem('users.department.name', nameField, 'Department name'),
+              makeItem('users.department.company.code', codeField, 'Company code'),
+            ],
+          },
+        },
+      },
+    };
+
+    const options = collectFieldAssignCascaderOptions({ formBlockModel, t: (s) => s });
+    const usersOption = options.find((item) => item.value === 'users');
+    const departmentOption = usersOption?.children?.find((item) => item.value === 'department');
 
-    expect(options.map((item) => item.value)).toContain('name');
-    expect(options.map((item) => item.value)).not.toContain('company');
+    expect(departmentOption?.children?.map((item) => item.value)).toContain('name');
+    expect(departmentOption?.children?.map((item) => item.value)).not.toContain('company');
   });
 
   it('hides lazy-loaded association selector options after two association levels', () => {

package/src/flow/components/fieldAssignOptions.ts

@@ -57,12 +57,11 @@ function getItemLabel(itemModel: any, t: (key: string) => string): string {
   return '';
 }
 
-function getLastPathSegment(path: string): string {
-  const segs = String(path || '')
+function splitFieldPath(path: string): string[] {
+  return String(path || '')
     .split('.')
     .map((s) => s.trim())
     .filter(Boolean);
-  return segs.length ? segs[segs.length - 1] : '';
 }
 
 type CollectionLike = {
@@ -70,6 +69,15 @@ type CollectionLike = {
   getFields?: () => unknown[];
 };
 
+type CollectionFieldLike = {
+  name?: unknown;
+  title?: unknown;
+  interface?: unknown;
+  target?: unknown;
+  isAssociationField?: () => boolean;
+  targetCollection?: CollectionLike | null;
+};
+
 function getCollectionFromFormBlockModel(model: any): CollectionLike | null {
   if (!model || typeof model !== 'object') return null;
   const collection = (model as any)?.collection || (model as any)?.context?.collection;
@@ -89,14 +97,7 @@ export function buildFieldAssignCascaderOptionsFromCollection(
   const out: FieldAssignCascaderOption[] = [];
   for (const rawField of fields) {
     if (!rawField) continue;
-    const f = rawField as {
-      name?: unknown;
-      title?: unknown;
-      interface?: unknown;
-      target?: unknown;
-      isAssociationField?: () => boolean;
-      targetCollection?: any;
-    };
+    const f = rawField as CollectionFieldLike;
     const fieldInterface = typeof f.interface === 'string' ? f.interface : undefined;
     if (!fieldInterface) continue;
     if (fieldInterface === 'formula') continue;
@@ -123,23 +124,143 @@ export function buildFieldAssignCascaderOptionsFromCollection(
 function mergeRootOptions(
   configured: FieldAssignCascaderOption[],
   allFields: FieldAssignCascaderOption[],
+): FieldAssignCascaderOption[] {
+  return mergeCascaderOptions(configured, allFields);
+}
+
+function mergeCascaderOptions(
+  configured: FieldAssignCascaderOption[],
+  allFields: FieldAssignCascaderOption[],
 ): FieldAssignCascaderOption[] {
   const configuredList = Array.isArray(configured) ? configured : [];
   const allList = Array.isArray(allFields) ? allFields : [];
+  const result = configuredList.map((item) => cloneCascaderOption(item));
 
-  const configuredValues = new Set<string>();
-  for (const it of configuredList) {
-    const v = it?.value ? String(it.value) : '';
-    if (v) configuredValues.add(v);
+  for (const item of allList) {
+    mergeCascaderOptionInto(result, item);
   }
 
-  const extra = allList.filter((it) => {
-    const v = it?.value ? String(it.value) : '';
-    if (!v) return false;
-    return !configuredValues.has(v);
-  });
+  return result;
+}
+
+function cloneCascaderOption(option: FieldAssignCascaderOption): FieldAssignCascaderOption {
+  return {
+    ...option,
+    children: option.children?.map((child) => cloneCascaderOption(child)),
+  };
+}
+
+function mergeCascaderOptionInto(options: FieldAssignCascaderOption[], source: FieldAssignCascaderOption) {
+  const value = source?.value ? String(source.value) : '';
+  if (!value) return;
+
+  const existing = options.find((item) => String(item?.value || '') === value);
+  if (!existing) {
+    options.push(cloneCascaderOption(source));
+    return;
+  }
+
+  if (!existing.label && source.label) {
+    existing.label = source.label;
+  }
+  if (source.isLeaf === false || existing.children?.length || source.children?.length) {
+    existing.isLeaf = false;
+  }
+  if (source.loading) {
+    existing.loading = source.loading;
+  }
+  if (source.children?.length) {
+    existing.children = mergeCascaderOptions(existing.children || [], source.children);
+  }
+}
+
+function getCollectionField(collection: CollectionLike | null, name: string): CollectionFieldLike | undefined {
+  const field = typeof collection?.getField === 'function' ? collection.getField(name) : undefined;
+  return field && typeof field === 'object' ? (field as CollectionFieldLike) : undefined;
+}
+
+function isAssociationFieldLike(field?: CollectionFieldLike | null) {
+  return !!(field?.isAssociationField?.() || field?.target || field?.targetCollection);
+}
+
+function getFieldLabelFromCollection(collection: CollectionLike | null, name: string, t: (key: string) => string) {
+  const field = getCollectionField(collection, name);
+  const title = typeof field?.title === 'string' && field.title ? field.title : name;
+  return t(title);
+}
+
+function getAssociationDepthFromFieldPath(
+  rootCollection: CollectionLike | null,
+  segments: string[],
+): number | undefined {
+  if (!rootCollection) return undefined;
+
+  let collection: CollectionLike | null = rootCollection;
+  let associationDepth = 0;
+  for (let index = 0; index < segments.length; index++) {
+    const field = getCollectionField(collection, segments[index]);
+    if (!field) return undefined;
+
+    if (isAssociationFieldLike(field)) {
+      associationDepth += 1;
+      collection = field.targetCollection || null;
+      continue;
+    }
+
+    if (index < segments.length - 1) return undefined;
+  }
+
+  return associationDepth;
+}
+
+function shouldIncludeConfiguredFieldPath(options: {
+  segments: string[];
+  rootCollection: CollectionLike | null;
+  leafField?: CollectionFieldLike | null;
+  maxAssociationFieldDepth: number;
+}) {
+  const resolvedAssociationDepth = getAssociationDepthFromFieldPath(options.rootCollection, options.segments);
+  if (typeof resolvedAssociationDepth === 'number') {
+    return resolvedAssociationDepth <= options.maxAssociationFieldDepth;
+  }
+
+  const leafIsAssociation = isAssociationFieldLike(options.leafField);
+  const maxPathLength = leafIsAssociation ? options.maxAssociationFieldDepth : options.maxAssociationFieldDepth + 1;
+  return options.segments.length <= maxPathLength;
+}
+
+function buildNestedOptionFromFieldPath(options: {
+  targetPath: string;
+  leaf: FieldAssignCascaderOption;
+  rootCollection: CollectionLike | null;
+  t: (key: string) => string;
+}): FieldAssignCascaderOption {
+  const segments = splitFieldPath(options.targetPath);
+  if (segments.length <= 1) {
+    return options.leaf;
+  }
+
+  const build = (index: number, collection: CollectionLike | null): FieldAssignCascaderOption => {
+    const value = segments[index];
+    const isLast = index === segments.length - 1;
+    if (isLast) {
+      return {
+        ...options.leaf,
+        value,
+      };
+    }
+
+    const field = getCollectionField(collection, value);
+    const nextCollection = field?.targetCollection || null;
+    return {
+      label: getFieldLabelFromCollection(collection, value, options.t),
+      value,
+      isLeaf: false,
+      children: [build(index + 1, nextCollection)],
+    };
+  };
 
-  return [...configuredList, ...extra];
+  return build(0, options.rootCollection);
 }
 
 export function collectFieldAssignCascaderOptions(options: {
@@ -167,7 +288,8 @@ export function collectFieldAssignCascaderOptions(options: {
       const targetPath = getItemFieldPath(item);
       if (!targetPath) continue;
 
-      const seg = getLastPathSegment(targetPath);
+      const segments = splitFieldPath(targetPath);
+      const seg = segments[segments.length - 1];
       if (!seg) continue;
 
       const node: FieldAssignCascaderOption = {
@@ -179,10 +301,16 @@ export function collectFieldAssignCascaderOptions(options: {
       const childItems = fieldModel?.subModels?.grid?.subModels?.items;
       const cf: (CollectionField & { target?: unknown; targetCollection?: unknown }) | undefined =
         fieldModel?.context?.collectionField;
-      const isAssociation = !!(cf?.isAssociationField?.() || cf?.target || cf?.targetCollection);
+      const isAssociation = isAssociationFieldLike(cf);
       const hasTargetCollection = !!cf?.targetCollection;
-      const associationDepth = isAssociation ? targetPath.split('.').filter(Boolean).length : 0;
-      if (isAssociation && associationDepth > maxAssociationFieldDepth) {
+      if (
+        !shouldIncludeConfiguredFieldPath({
+          segments,
+          rootCollection,
+          leafField: cf,
+          maxAssociationFieldDepth,
+        })
+      ) {
         continue;
       }
 
@@ -203,7 +331,7 @@ export function collectFieldAssignCascaderOptions(options: {
             node.isLeaf = true;
           }
         }
-        out.push(node);
+        mergeCascaderOptionInto(out, buildNestedOptionFromFieldPath({ targetPath, leaf: node, rootCollection, t }));
         continue;
       }
 
@@ -215,7 +343,7 @@ export function collectFieldAssignCascaderOptions(options: {
         node.isLeaf = true;
       }
 
-      out.push(node);
+      mergeCascaderOptionInto(out, buildNestedOptionFromFieldPath({ targetPath, leaf: node, rootCollection, t }));
     }
 
     return out;

package/src/flow/getViewDiffAndUpdateHidden.tsx

@@ -33,6 +33,7 @@ export const getKey = (viewItem: ViewItem) => {
     stableStringify(params.viewUid),
     stableStringify(params.sourceId),
     stableStringify(params.filterByTk),
+    stableStringify(params.openViewRouteState),
     String(index),
   ];
 

package/src/flow/models/base/ActionModelCore.tsx

@@ -25,7 +25,7 @@ export function ActionWithoutPermission(props) {
     const dataSourcePrefix = `${t(dataSource.displayName || dataSource.key)} > `;
     const collectionPrefix = collection ? `${t(collection.title) || collection.name || collection.tableName} ` : '';
     return `${dataSourcePrefix}${collectionPrefix}`;
-  }, []);
+  }, [collection, dataSource.displayName, dataSource.key, t]);
   const { actionName } = props?.forbidden || model.forbidden;
   const messageValue = useMemo(() => {
     return t(
@@ -143,10 +143,11 @@ export class ActionModel<T extends DefaultStructure = DefaultStructure> extends
   renderButton() {
     const { iconOnly, ...props } = this.props;
     const icon = this.getIcon() ? <Icon type={this.getIcon() as any} /> : undefined;
+    const titleContent = iconOnly && icon ? null : props.children || this.getTitle();
 
     return (
       <Button {...props} onClick={this.onClick.bind(this)} icon={icon}>
-        {iconOnly ? null : props.children || this.getTitle()}
+        {titleContent}
       </Button>
     );
   }
@@ -162,11 +163,12 @@ export class ActionModel<T extends DefaultStructure = DefaultStructure> extends
   renderHiddenInConfig(): React.ReactNode | undefined {
     const { iconOnly, ...props } = this.props;
     const icon = this.getIcon() ? <Icon type={this.getIcon() as any} /> : undefined;
+    const titleContent = iconOnly && icon ? null : props.children || this.getTitle();
     if (this.forbidden) {
       return (
         <ActionWithoutPermission>
           <Button {...props} onClick={this.onClick.bind(this)} icon={icon} style={{ opacity: '0.3' }}>
-            {iconOnly ? null : props.children || this.getTitle()}
+            {titleContent}
           </Button>
         </ActionWithoutPermission>
       );
@@ -174,7 +176,7 @@ export class ActionModel<T extends DefaultStructure = DefaultStructure> extends
     return (
       <Tooltip title={this.context.t('The button is hidden and only visible when the UI Editor is active')}>
         <Button {...props} onClick={this.onClick.bind(this)} icon={icon} style={{ opacity: '0.3' }}>
-          {iconOnly ? null : props.children || this.getTitle()}
+          {titleContent}
         </Button>
       </Tooltip>
     );

package/src/flow/models/base/__tests__/ActionModelCore.render.test.tsx

@@ -0,0 +1,37 @@
+import { render, screen } from '@nocobase/test/client';
+import { FlowEngine, FlowEngineProvider } from '@nocobase/flow-engine';
+import { App, ConfigProvider } from 'antd';
+import React from 'react';
+import { describe, expect, it } from 'vitest';
+import { ActionModel } from '../ActionModel';
+
+class NoIconActionModel extends ActionModel {
+  defaultProps = {
+    type: 'link' as const,
+    title: 'Open details',
+  };
+}
+
+describe('ActionModel rendering', () => {
+  it('shows the title when iconOnly is true but no icon is configured', () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ NoIconActionModel });
+    const model = engine.createModel<NoIconActionModel>({
+      use: 'NoIconActionModel',
+      props: {
+        title: 'Open details',
+        iconOnly: true,
+      },
+    });
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <ConfigProvider>
+          <App>{model.render()}</App>
+        </ConfigProvider>
+      </FlowEngineProvider>,
+    );
+
+    expect(screen.getByRole('button', { name: 'Open details' })).toBeInTheDocument();
+  });
+});

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

@@ -210,7 +210,7 @@ FilterFormCustomFieldModel.registerFlow({
           'x-decorator': 'FormItem',
           required: true,
           description:
-            '{{t("Randomly generated and can be modified. Support letters, numbers and underscores, must start with an letter.")}}',
+            '{{t("Randomly generated and can be modified. Support letters, numbers and underscores, must start with a letter.")}}',
         },
         source: {
           type: 'array',

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

@@ -117,7 +117,7 @@ FormSubmitActionModel.registerFlow({
         try {
           ctx.model.setProps('loading', true);
           const { submitHandler } = await import('./submitHandler');
-          await submitHandler(ctx, params);
+          return await submitHandler(ctx, params);
         } catch (error) {
           ctx.model.setProps('loading', false);
           if (error instanceof FlowExitAllException) {

package/src/flow/models/blocks/form/__tests__/submitHandler.test.ts

@@ -9,6 +9,7 @@
 
 import { SingleRecordResource } from '@nocobase/flow-engine';
 import { describe, expect, it, vi } from 'vitest';
+import { EditFormModel } from '../EditFormModel';
 import { submitHandler } from '../submitHandler';
 
 describe('submitHandler', () => {
@@ -52,13 +53,14 @@ describe('submitHandler', () => {
       t: (value: string) => value,
     };
 
-    await submitHandler(ctx, {
+    const responseRecord = await submitHandler(ctx, {
       assignedValues: {
         status: 'published',
         reviewer: 'Alice',
       },
     });
 
+    expect(responseRecord).toEqual({ id: 1 });
     expect(resource.save).toHaveBeenCalledWith(
       {
         title: 'Draft title',
@@ -68,4 +70,55 @@ describe('submitHandler', () => {
       undefined,
     );
   });
+
+  it('returns the refreshed record for edit forms when the save response is empty', async () => {
+    const refreshedRecord = { id: 2, title: 'Updated title' };
+    const resource = Object.create(SingleRecordResource.prototype);
+    resource.getMeta = vi.fn((key: string) => (key === 'currentFilterByTk' ? 2 : undefined));
+    resource.setFilterByTk = vi.fn(() => resource);
+    resource.save = vi.fn(async () => undefined);
+    resource.refresh = vi.fn(async () => undefined);
+    resource.getData = vi.fn(() => refreshedRecord);
+
+    const blockModel = Object.create(EditFormModel.prototype);
+    const form = {
+      validateFields: vi.fn(async () => undefined),
+      getFieldsValue: vi.fn(() => ({
+        title: 'Updated title',
+      })),
+    };
+    Object.defineProperty(blockModel, 'context', { value: { form } });
+    Object.defineProperty(blockModel, 'collection', {
+      value: {
+        name: 'posts',
+        getFilterByTK: (record: { id?: number }) => record.id,
+      },
+    });
+    blockModel.resetUserModifiedFields = vi.fn();
+
+    const responseRecord = await submitHandler(
+      {
+        resource,
+        blockModel,
+        model: {
+          getStepParams: vi.fn(),
+        },
+        message: {
+          error: vi.fn(),
+        },
+        t: (value: string) => value,
+      },
+      {},
+    );
+
+    expect(responseRecord).toBe(refreshedRecord);
+    expect(resource.setFilterByTk).toHaveBeenCalledWith(2);
+    expect(resource.save).toHaveBeenCalledWith(
+      {
+        title: 'Updated title',
+      },
+      undefined,
+    );
+    expect(resource.refresh).toHaveBeenCalled();
+  });
 });

package/src/flow/models/blocks/form/submitHandler.ts

@@ -12,6 +12,16 @@ import { mergeAssignFieldValues, resolveAssignFieldValues } from '../assign-form
 import type { FormBlockModel } from './FormBlockModel';
 import { omitHiddenModelValuesFromSubmit, shouldSkipSubmitValidation, validateSubmitForm } from './submitValues';
 
+function getResponseRecord(response: unknown) {
+  if (!response || typeof response !== 'object') {
+    return response;
+  }
+  if ('data' in response) {
+    return (response as { data?: unknown }).data;
+  }
+  return response;
+}
+
 export async function submitHandler(ctx, params, cb?: (values?: any, filterByTk?: any) => void) {
   const resource = ctx.resource;
   const blockModel = ctx.blockModel as FormBlockModel;
@@ -41,30 +51,34 @@ export async function submitHandler(ctx, params, cb?: (values?: any, filterByTk?
         resource.setFilterByTk(currentFilterByTk);
       }
     }
-    const data: any = cb ? await cb(values) : await resource.save(values, params.requestConfig);
+    const data: unknown = cb ? await cb(values) : await resource.save(values, params.requestConfig);
+    let responseRecord = getResponseRecord(data);
     if (isEditFormModel) {
       resource.isNewRecord = false;
       // 编辑表单保存成功后，表单应回到“已同步”状态：下一次刷新应允许覆盖为服务端值
       blockModel.resetUserModifiedFields?.();
       await resource.refresh();
+      responseRecord = responseRecord ?? resource.getData?.();
     } else {
       blockModel.form.resetFields();
       blockModel.emitter.emit('onFieldReset');
       blockModel.resetUserModifiedFields?.();
       blockModel.formValueRuntime?.resetAfterFormReset?.();
       if (ctx.view.inputArgs.collectionName === blockModel.collection.name && ctx.view.inputArgs.onChange) {
-        ctx.view.inputArgs.onChange(data?.data);
+        ctx.view.inputArgs.onChange(responseRecord);
       }
     }
+    return responseRecord;
   } else if (resource instanceof MultiRecordResource) {
     const currentFilterByTk = resource.getMeta('currentFilterByTk');
     if (!currentFilterByTk) {
       ctx.message.error(ctx.t('No filterByTk found for multi-record resource.'));
       return;
     }
-    (await cb)
+    const data = cb
       ? await cb(values, currentFilterByTk)
       : await resource.update(currentFilterByTk, values, params.requestConfig);
     blockModel.resetUserModifiedFields?.();
+    return getResponseRecord(data) ?? blockModel.getCurrentRecord?.();
   }
 }